Check Network domain state in RuntimeTargetNetwork (#54082)

Summary:
Pull Request resolved: #54082

Changelog: [Internal]

Followup from D83238216.

Adds bookkeeping in `RuntimeTarget` to allow checking from the JS thread whether there is a session with the `Network` CDP enabled. We then use this in the implementation of `__NETWORK_REPORTER__.createDevToolsRequestId` as a more precise alternative to checking the `NetworkHandler` singleton's state.

This is a first step towards breaking up the `NetworkHandler` singleton, subsuming its responsibilities into the Target/Agent architecture of `jsinspector-modern` and fixing a variety of bugs in the process.

NOTE: The additions to `RuntimeTarget` are more general than just tracking the `Network` domain - I'll use them in an upcoming diff to fix a concrete bug related to concurrent session support in `DebuggerSessionObserver`.

Reviewed By: huntie

Differential Revision: D83847356

fbshipit-source-id: 3384e3feb44adbd9ed4d54a20875669d63ae8764

Author: motiz88

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <array>
+#include <limits>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * A statically-sized array with an enum class as the index type.
+ * Values are value-initialized (i.e. zero-initialized for integral types).
+ * Requires that the enum class has a kMaxValue member.
+ */
+template <class IndexType, class ValueType>
+  requires std::is_enum_v<IndexType> &&
+    std::is_same_v<std::underlying_type_t<IndexType>, int> &&
+    requires { IndexType::kMaxValue; } &&
+    (static_cast<int>(IndexType::kMaxValue) < std::numeric_limits<int>::max())
+
+class EnumArray {
+ public:
+  constexpr ValueType& operator[](IndexType i) {
+    return array_[static_cast<int>(i)];
+  }
+
+  constexpr const ValueType& operator[](IndexType i) const {
+    return array_[static_cast<int>(i)];
+  }
+
+  constexpr int size() const {
+    return size_;
+  }
+
+ private:
+  constexpr static int size_ = static_cast<int>(IndexType::kMaxValue) + 1;
+
+  std::array<ValueType, size_> array_{};
+};
+} // namespace facebook::react::jsinspector_modern

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

@@ -33,6 +33,11 @@ RuntimeAgent::RuntimeAgent(
       sessionState_.isLogDomainEnabled) {
     targetController_.notifyDebuggerSessionCreated();
   }
+
+  if (sessionState_.isNetworkDomainEnabled) {
+    targetController_.notifyDomainStateChanged(
+        RuntimeTargetController::Domain::Network, true, *this);
+  }
 }
 
 bool RuntimeAgent::handleRequest(const cdp::PreparsedRequest& req) {
@@ -67,6 +72,17 @@ bool RuntimeAgent::handleRequest(const cdp::PreparsedRequest& req) {
   if (req.method == "Log.disable" && sessionState_.isRuntimeDomainEnabled) {
     targetController_.notifyDebuggerSessionDestroyed();
   }
+
+  if (req.method == "Network.enable" || req.method == "Network.disable") {
+    targetController_.notifyDomainStateChanged(
+        RuntimeTargetController::Domain::Network,
+        sessionState_.isNetworkDomainEnabled,
+        *this);
+
+    // We are not responding to this request, just processing a side effect.
+    return false;
+  }
+
   if (delegate_) {
     return delegate_->handleRequest(req);
   }
@@ -108,6 +124,10 @@ RuntimeAgent::~RuntimeAgent() {
       sessionState_.isLogDomainEnabled) {
     targetController_.notifyDebuggerSessionDestroyed();
   }
+  if (sessionState_.isNetworkDomainEnabled) {
+    targetController_.notifyDomainStateChanged(
+        RuntimeTargetController::Domain::Network, false, *this);
+  }
 
   // TODO: Eventually, there may be more than one Runtime per Page, and we'll
   // need to store multiple agent states here accordingly. For now let's do

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

@@ -163,6 +163,34 @@ void RuntimeTarget::emitDebuggerSessionDestroyed() {
   });
 }
 
+void RuntimeTarget::enableSamplingProfiler() {
+  delegate_.enableSamplingProfiler();
+}
+
+void RuntimeTarget::disableSamplingProfiler() {
+  delegate_.disableSamplingProfiler();
+}
+
+tracing::RuntimeSamplingProfile RuntimeTarget::collectSamplingProfile() {
+  return delegate_.collectSamplingProfile();
+}
+
+void RuntimeTarget::notifyDomainStateChanged(
+    Domain domain,
+    bool enabled,
+    const RuntimeAgent& notifyingAgent) {
+  if (enabled) {
+    agentsByEnabledDomain_[domain].insert(&notifyingAgent);
+  } else {
+    agentsByEnabledDomain_[domain].erase(&notifyingAgent);
+  }
+  threadSafeDomainStatus_[domain] = !agentsByEnabledDomain_[domain].empty();
+}
+
+bool RuntimeTarget::isDomainEnabled(Domain domain) const {
+  return threadSafeDomainStatus_[domain];
+}
+
 RuntimeTargetController::RuntimeTargetController(RuntimeTarget& target)
     : target_(target) {}
 
@@ -192,16 +220,11 @@ RuntimeTargetController::collectSamplingProfile() {
   return target_.collectSamplingProfile();
 }
 
-void RuntimeTarget::enableSamplingProfiler() {
-  delegate_.enableSamplingProfiler();
-}
-
-void RuntimeTarget::disableSamplingProfiler() {
-  delegate_.disableSamplingProfiler();
-}
-
-tracing::RuntimeSamplingProfile RuntimeTarget::collectSamplingProfile() {
-  return delegate_.collectSamplingProfile();
+void RuntimeTargetController::notifyDomainStateChanged(
+    Domain domain,
+    bool enabled,
+    const RuntimeAgent& notifyingAgent) {
+  target_.notifyDomainStateChanged(domain, enabled, notifyingAgent);
 }
 
 } // namespace facebook::react::jsinspector_modern

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

@@ -8,6 +8,7 @@
 #pragma once
 
 #include "ConsoleMessage.h"
+#include "EnumArray.h"
 #include "ExecutionContext.h"
 #include "InspectorInterfaces.h"
 #include "RuntimeAgent.h"
@@ -123,6 +124,8 @@ class RuntimeTargetDelegate {
  */
 class RuntimeTargetController {
  public:
+  enum class Domain { Network, kMaxValue };
+
   explicit RuntimeTargetController(RuntimeTarget& target);
 
   /**
@@ -144,6 +147,15 @@ class RuntimeTargetController {
    */
   void notifyDebuggerSessionDestroyed();
 
+  /**
+   * Notifies the target that an agent has received an enable or disable
+   * message for the given domain.
+   */
+  void notifyDomainStateChanged(
+      Domain domain,
+      bool enabled,
+      const RuntimeAgent& notifyingAgent);
+
   /**
    * Start sampling profiler for the corresponding RuntimeTarget.
    */
@@ -239,6 +251,8 @@ class JSINSPECTOR_EXPORT RuntimeTarget
   tracing::RuntimeSamplingProfile collectSamplingProfile();
 
  private:
+  using Domain = RuntimeTargetController::Domain;
+
   /**
    * Constructs a new RuntimeTarget. The caller must call setExecutor
    * immediately afterwards.
@@ -267,6 +281,19 @@ class JSINSPECTOR_EXPORT RuntimeTarget
   WeakList<RuntimeAgent> agents_;
   RuntimeTargetController controller_{*this};
 
+  /**
+   * Keeps track of the agents that have enabled various domains.
+   */
+  EnumArray<Domain, std::unordered_set<const RuntimeAgent*>>
+      agentsByEnabledDomain_;
+
+  /**
+   * For each Domain, contains true if the domain has been enabled by any
+   * active agent. Unlike agentsByEnabledDomain_, this is safe to read from any
+   * thread. \see isDomainEnabled.
+   */
+  EnumArray<Domain, std::atomic<bool>> threadSafeDomainStatus_{};
+
   /**
    * This TracingAgent is owned by the InstanceTracingAgent, both are bound to
    * the lifetime of their corresponding targets and the lifetime of the tracing
@@ -323,6 +350,23 @@ class JSINSPECTOR_EXPORT RuntimeTarget
    */
   std::string createNetworkRequestId();
 
+  /**
+   * Notifies the target that an agent has received an enable or disable
+   * message for the given domain.
+   */
+  void notifyDomainStateChanged(
+      Domain domain,
+      bool enabled,
+      const RuntimeAgent& notifyingAgent);
+
+  /**
+   * Checks whether the given domain is enabled in at least one session
+   * that is currently connected. This may be called from any thread, with
+   * the caveat that the result can change at arbitrary times unless the caller
+   * is on the inspector thread.
+   */
+  bool isDomainEnabled(Domain domain) const;
+
   // Necessary to allow RuntimeAgent to access RuntimeTarget's internals in a
   // controlled way (i.e. only RuntimeTargetController gets friend access, while
   // RuntimeAgent itself doesn't).

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

@@ -52,10 +52,7 @@ void RuntimeTarget::installNetworkReporterAPI() {
     std::optional<std::string> devToolsRequestId;
     tryExecuteSync(selfWeak, [&](RuntimeTarget& self) {
       devToolsRequestId = self.createNetworkRequestId();
-      // TODO(moti): Instead of checking the singleton state,
-      // directly check whether the current target has a session
-      // with the Network domain enabled.
-      if (NetworkHandler::getInstance().isEnabled()) {
+      if (self.isDomainEnabled(Domain::Network)) {
         // Q: Why is it safe to use self.delegate_ here?
         // A: Because the caller of InspectorTarget::registerRuntime
         // is explicitly required to guarantee that the delegate not