Support using the Network domain in multiple concurrent sessions

Summary: Changelog: [General][Fixed] Send network events to all CDP clients with the Network domain enabled

Differential Revision: D90888854

Author: motiz88

packages/react-native/ReactCommon/jsinspector-modern/NetworkIOAgent.cpp

@@ -259,6 +259,13 @@ class Stream : public NetworkRequestListener,
 };
 } // namespace
 
+NetworkIOAgent::~NetworkIOAgent() {
+  if (networkAgentId_) {
+    NetworkHandler::getInstance().disableAgent(*networkAgentId_);
+    networkAgentId_ = std::nullopt;
+  }
+}
+
 bool NetworkIOAgent::handleRequest(
     const cdp::PreparsedRequest& req,
     LoadNetworkResourceDelegate& delegate) {
@@ -278,15 +285,17 @@ bool NetworkIOAgent::handleRequest(
 
     // @cdp Network.enable support is experimental.
     if (req.method == "Network.enable") {
-      networkHandler.setFrontendChannel(frontendChannel_);
-      networkHandler.enable();
+      networkAgentId_ = networkHandler.enableAgent(frontendChannel_);
       // NOTE: Domain enable/disable responses are sent by HostAgent.
       return false;
     }
 
     // @cdp Network.disable support is experimental.
     if (req.method == "Network.disable") {
-      networkHandler.disable();
+      if (networkAgentId_) {
+        networkHandler.disableAgent(*networkAgentId_);
+        networkAgentId_ = std::nullopt;
+      }
       // NOTE: Domain enable/disable responses are sent by HostAgent.
       return false;
     }

packages/react-native/ReactCommon/jsinspector-modern/NetworkIOAgent.h

@@ -12,6 +12,7 @@
 
 #include <folly/dynamic.h>
 #include <jsinspector-modern/cdp/CdpJson.h>
+#include <jsinspector-modern/network/NetworkHandler.h>
 
 #include <string>
 #include <unordered_map>
@@ -211,6 +212,13 @@ class NetworkIOAgent {
   {
   }
 
+  ~NetworkIOAgent();
+
+  NetworkIOAgent(const NetworkIOAgent &) = delete;
+  NetworkIOAgent &operator=(const NetworkIOAgent &) = delete;
+  NetworkIOAgent(NetworkIOAgent &&) = delete;
+  NetworkIOAgent &operator=(NetworkIOAgent &&) = delete;
+
   /**
    * Handle a CDP request. The response will be sent over the provided
    * \c FrontendChannel synchronously or asynchronously.
@@ -247,6 +255,12 @@ class NetworkIOAgent {
    */
   unsigned long nextStreamId_{0};
 
+  /**
+   * If non-nullopt, indicates that this agent has enabled the Network domain
+   * via NetworkHandler, storing the agent ID for cleanup.
+   */
+  std::optional<NetworkHandler::AgentId> networkAgentId_;
+
   /**
    * Begin loading an HTTP resource, delegating platform-specific
    * implementation, responding to the frontend on headers received or on error.

packages/react-native/ReactCommon/jsinspector-modern/network/NetworkHandler.cpp

@@ -37,28 +37,32 @@ NetworkHandler& NetworkHandler::getInstance() {
   return instance;
 }
 
-void NetworkHandler::setFrontendChannel(FrontendChannel frontendChannel) {
-  frontendChannel_ = std::move(frontendChannel);
+NetworkHandler::AgentId NetworkHandler::enableAgent(
+    FrontendChannel frontendChannel) {
+  std::lock_guard<std::mutex> lock(agentsMutex_);
+  AgentId id = nextAgentId_++;
+  agents_.push_back({id, std::move(frontendChannel)});
+  enabled_.store(true, std::memory_order_release);
+  return id;
 }
 
-bool NetworkHandler::enable() {
-  if (enabled_.load(std::memory_order_acquire)) {
-    return false;
-  }
+void NetworkHandler::disableAgent(AgentId agentId) {
+  std::lock_guard<std::mutex> lock(agentsMutex_);
+  agents_.remove_if(
+      [agentId](const AgentRecord& r) { return r.id == agentId; });
+  if (agents_.empty()) {
+    enabled_.store(false, std::memory_order_release);
 
-  enabled_.store(true, std::memory_order_release);
-  return true;
+    std::lock_guard<std::mutex> lock2(requestBodyMutex_);
+    responseBodyBuffer_.clear();
+  }
 }
 
-bool NetworkHandler::disable() {
-  if (!enabled_.load(std::memory_order_acquire)) {
-    return false;
+void NetworkHandler::sendToAllAgents(std::string_view message) {
+  std::lock_guard<std::mutex> lock(agentsMutex_);
+  for (const auto& agent : agents_) {
+    agent.channel(message);
   }
-
-  enabled_.store(false, std::memory_order_release);
-  std::lock_guard<std::mutex> lock(requestBodyMutex_);
-  responseBodyBuffer_.clear();
-  return true;
 }
 
 void NetworkHandler::onRequestWillBeSent(
@@ -89,7 +93,7 @@ void NetworkHandler::onRequestWillBeSent(
       .redirectResponse = redirectResponse,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.requestWillBeSent", params.toDynamic()));
 }
 
@@ -106,7 +110,7 @@ void NetworkHandler::onRequestWillBeSentExtraInfo(
       .connectTiming = {.requestTime = getCurrentUnixTimestampSeconds()},
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification(
           "Network.requestWillBeSentExtraInfo", params.toDynamic()));
 }
@@ -133,7 +137,7 @@ void NetworkHandler::onResponseReceived(
       .hasExtraInfo = false,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.responseReceived", params.toDynamic()));
 }
 
@@ -152,7 +156,7 @@ void NetworkHandler::onDataReceived(
       .encodedDataLength = encodedDataLength,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.dataReceived", params.toDynamic()));
 }
 
@@ -169,7 +173,7 @@ void NetworkHandler::onLoadingFinished(
       .encodedDataLength = encodedDataLength,
   };
 
-  frontendChannel_(
+  sendToAllAgents(
       cdp::jsonNotification("Network.loadingFinished", params.toDynamic()));
 }
 
@@ -192,7 +196,7 @@ void NetworkHandler::onLoadingFailed(
         .canceled = cancelled,
     };
 
-    frontendChannel_(
+    sendToAllAgents(
         cdp::jsonNotification("Network.loadingFailed", params.toDynamic()));
   }
 }

packages/react-native/ReactCommon/jsinspector-modern/network/NetworkHandler.h

@@ -13,6 +13,7 @@
 #include <folly/dynamic.h>
 
 #include <atomic>
+#include <list>
 #include <mutex>
 #include <string>
 #include <tuple>
@@ -33,27 +34,25 @@ using Headers = std::map<std::string, std::string>;
  */
 class NetworkHandler {
  public:
-  static NetworkHandler &getInstance();
-
   /**
-   * Set the channel used to send CDP events to the frontend. This should be
-   * supplied before calling `enable`.
+   * Ephemeral identifier for a registered agent, used to unregister.
    */
-  void setFrontendChannel(FrontendChannel frontendChannel);
+  using AgentId = uint32_t;
+
+  static NetworkHandler &getInstance();
 
   /**
-   * Enable network debugging. Returns `false` if already enabled.
-   *
-   * @cdp Network.enable
+   * Register a frontend channel for receiving Network domain events.
+   * Implicitly enables the domain if this is the first agent.
+   * \returns An AgentId to be passed to disableAgent() on cleanup.
    */
-  bool enable();
+  AgentId enableAgent(FrontendChannel frontendChannel);
 
   /**
-   * Disable network debugging. Returns `false` if not initially enabled.
-   *
-   * @cdp Network.disable
+   * Unregister a frontend channel by its AgentId.
+   * Implicitly disables the domain if this was the last agent.
    */
-  bool disable();
+  void disableAgent(AgentId agentId);
 
   /**
    * Returns whether network debugging is currently enabled.
@@ -134,7 +133,19 @@ class NetworkHandler {
 
   std::optional<folly::dynamic> consumeStoredRequestInitiator(const std::string &requestId);
 
-  FrontendChannel frontendChannel_;
+  /**
+   * Send a message to all registered frontend channels.
+   */
+  void sendToAllAgents(std::string_view message);
+
+  struct AgentRecord {
+    AgentId id;
+    FrontendChannel channel;
+  };
+
+  std::list<AgentRecord> agents_;
+  AgentId nextAgentId_{1};
+  std::mutex agentsMutex_;
 
   std::map<std::string, std::string> resourceTypeMap_{};
   std::map<std::string, folly::dynamic> requestInitiatorById_{};

packages/react-native/ReactCommon/jsinspector-modern/tests/NetworkReporterTest.cpp

@@ -588,6 +588,40 @@ TEST_P(NetworkReporterTest, testCreateRequestIdWithoutNetworkDomain) {
   EXPECT_NE(id1, id2);
 }
 
+TEST_P(NetworkReporterTest, testTwoSessionsReceiveNetworkEvents) {
+  auto secondary = this->connectSecondary();
+
+  this->expectMessageFromPage(JsonEq(R"({"id": 1, "result": {}})"));
+  this->toPage_->sendMessage(R"({"id": 1, "method": "Network.enable"})");
+
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 2, "result": {}})")));
+  secondary.toPage().sendMessage(R"({"id": 2, "method": "Network.enable"})");
+
+  // Both sessions should receive the network event
+  this->expectMessageFromPage(JsonParsed(AllOf(
+      AtJsonPtr("/method", "Network.requestWillBeSent"),
+      AtJsonPtr("/params/requestId", "multi-session-request"))));
+  EXPECT_CALL(
+      secondary.fromPage(),
+      onMessage(JsonParsed(AllOf(
+          AtJsonPtr("/method", "Network.requestWillBeSent"),
+          AtJsonPtr("/params/requestId", "multi-session-request")))));
+
+  RequestInfo requestInfo;
+  requestInfo.url = "https://example.com/test";
+  requestInfo.httpMethod = "GET";
+  NetworkReporter::getInstance().reportRequestStart(
+      "multi-session-request", requestInfo, 0, std::nullopt);
+
+  this->expectMessageFromPage(JsonEq(R"({"id": 3, "result": {}})"));
+  this->toPage_->sendMessage(R"({"id": 3, "method": "Network.disable"})");
+
+  EXPECT_CALL(
+      secondary.fromPage(), onMessage(JsonEq(R"({"id": 4, "result": {}})")));
+  secondary.toPage().sendMessage(R"({"id": 4, "method": "Network.disable"})");
+}
+
 struct NetworkReporterTracingTestParams {
   bool enableNetworkEventReporting;
   bool enableNetworkDomain;