jsinspector: capture ReactNativeApplication domain notifications (react#54244)

Summary:

# Changelog: [Internal]

Refactors the logic a bit, and adds `ReactNativeApplication` domain to the ones that are currently being tracked.

We will use it as a signal for installation of `console.createTask()` implementation.

Differential Revision: D85274860

Author: hoxyq

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

@@ -224,16 +224,18 @@ class HostAgent::Impl final {
             std::move(stashedTraceRecording.value()));
       }
 
+      // Percolate down to the RuntimeAgent.
       return {
-          .isFinishedHandlingRequest = true,
+          .isFinishedHandlingRequest = false,
           .shouldSendOKResponse = true,
       };
     }
     if (req.method == "ReactNativeApplication.disable") {
       sessionState_.isReactNativeApplicationDomainEnabled = false;
 
+      // Percolate down to the RuntimeAgent.
       return {
-          .isFinishedHandlingRequest = true,
+          .isFinishedHandlingRequest = false,
           .shouldSendOKResponse = true,
       };
     }

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

@@ -43,6 +43,11 @@ RuntimeAgent::RuntimeAgent(
     targetController_.notifyDomainStateChanged(
         RuntimeTargetController::Domain::Network, true, *this);
   }
+
+  if (sessionState_.isReactNativeApplicationDomainEnabled) {
+    targetController_.notifyDomainStateChanged(
+        RuntimeTargetController::Domain::ReactNativeApplication, true, *this);
+  }
 }
 
 bool RuntimeAgent::handleRequest(const cdp::PreparsedRequest& req) {
@@ -84,6 +89,16 @@ bool RuntimeAgent::handleRequest(const cdp::PreparsedRequest& req) {
         sessionState_.isNetworkDomainEnabled,
         *this);
 
+    // We are not responding to this request, just processing a side effect.
+    return false;
+  } else if (
+      req.method == "ReactNativeApplication.enable" ||
+      req.method == "ReactNativeApplication.disable") {
+    targetController_.notifyDomainStateChanged(
+        RuntimeTargetController::Domain::ReactNativeApplication,
+        sessionState_.isReactNativeApplicationDomainEnabled,
+        *this);
+
     // We are not responding to this request, just processing a side effect.
     return false;
   }
@@ -137,6 +152,10 @@ RuntimeAgent::~RuntimeAgent() {
     targetController_.notifyDomainStateChanged(
         RuntimeTargetController::Domain::Network, false, *this);
   }
+  if (sessionState_.isReactNativeApplicationDomainEnabled) {
+    targetController_.notifyDomainStateChanged(
+        RuntimeTargetController::Domain::ReactNativeApplication, 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

@@ -179,40 +179,80 @@ void RuntimeTarget::notifyDomainStateChanged(
     Domain domain,
     bool enabled,
     const RuntimeAgent& notifyingAgent) {
-  bool runtimeAndLogStatusBefore = false, runtimeAndLogStatusAfter = false;
-  if (domain == Domain::Log || domain == Domain::Runtime) {
-    runtimeAndLogStatusBefore =
-        agentsByEnabledDomain_[Domain::Runtime].contains(&notifyingAgent) &&
-        agentsByEnabledDomain_[Domain::Log].contains(&notifyingAgent);
-  }
-
-  if (enabled) {
-    agentsByEnabledDomain_[domain].insert(&notifyingAgent);
-  } else {
-    agentsByEnabledDomain_[domain].erase(&notifyingAgent);
-  }
-  threadSafeDomainStatus_[domain] = !agentsByEnabledDomain_[domain].empty();
-
-  if (domain == Domain::Log || domain == Domain::Runtime) {
-    runtimeAndLogStatusAfter =
-        agentsByEnabledDomain_[Domain::Runtime].contains(&notifyingAgent) &&
-        agentsByEnabledDomain_[Domain::Log].contains(&notifyingAgent);
+  auto [domainStateChangedLocally, domainStateChangedGlobally] =
+      processDomainChange(domain, enabled, notifyingAgent);
+
+  switch (domain) {
+    case Domain::Log:
+    case Domain::Runtime: {
+      auto otherDomain = domain == Domain::Log ? Domain::Runtime : Domain::Log;
+      // There should be an agent that enables both Log and Runtime domains.
+      if (!agentsByEnabledDomain_[otherDomain].contains(&notifyingAgent)) {
+        break;
+      }
 
-    if (runtimeAndLogStatusBefore != runtimeAndLogStatusAfter) {
-      if (runtimeAndLogStatusAfter) {
+      if (domainStateChangedGlobally && enabled) {
+        assert(agentsWithRuntimeAndLogDomainsEnabled_ == 0);
+        emitDebuggerSessionCreated();
+        ++agentsWithRuntimeAndLogDomainsEnabled_;
+      } else if (domainStateChangedGlobally) {
+        assert(agentsWithRuntimeAndLogDomainsEnabled_ == 1);
+        emitDebuggerSessionDestroyed();
+        --agentsWithRuntimeAndLogDomainsEnabled_;
+      } else if (domainStateChangedLocally && enabled) {
+        // This is a case when given domain was already enabled by other Agent,
+        // so global state didn't change.
         if (++agentsWithRuntimeAndLogDomainsEnabled_ == 1) {
           emitDebuggerSessionCreated();
         }
-      } else {
-        assert(agentsWithRuntimeAndLogDomainsEnabled_ > 0);
+      } else if (domainStateChangedLocally) {
         if (--agentsWithRuntimeAndLogDomainsEnabled_ == 0) {
           emitDebuggerSessionDestroyed();
         }
       }
+
+      break;
+    }
+    case Domain::ReactNativeApplication: {
+      if (domainStateChangedGlobally && enabled) {
+        // installConsoleCreateTask();
+      } else if (domainStateChangedGlobally) {
+        // stubConsoleCreateTask();
+      }
+
+      break;
+    }
+    case Domain::Network:
+      break;
+    case Domain::kMaxValue: {
+      throw std::logic_error("Unexpected kMaxValue domain value provided");
     }
   }
 }
 
+std::pair<bool, bool> RuntimeTarget::processDomainChange(
+    Domain domain,
+    bool enabled,
+    const RuntimeAgent& notifyingAgent) {
+  bool domainHadAgentsBefore = !agentsByEnabledDomain_[domain].empty();
+  bool domainHasBeenEnabledBefore =
+      agentsByEnabledDomain_[domain].contains(&notifyingAgent);
+
+  if (enabled) {
+    agentsByEnabledDomain_[domain].insert(&notifyingAgent);
+  } else {
+    agentsByEnabledDomain_[domain].erase(&notifyingAgent);
+  }
+  threadSafeDomainStatus_[domain] = !agentsByEnabledDomain_[domain].empty();
+
+  bool domainHasAgentsAfter = !agentsByEnabledDomain_[domain].empty();
+
+  return {
+      domainHasBeenEnabledBefore ^ enabled,
+      domainHadAgentsBefore ^ domainHasAgentsAfter,
+  };
+}
+
 bool RuntimeTarget::isDomainEnabled(Domain domain) const {
   return threadSafeDomainStatus_[domain];
 }

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

@@ -21,6 +21,7 @@
 #include <jsinspector-modern/tracing/TraceRecordingState.h>
 
 #include <memory>
+#include <utility>
 
 #ifndef JSINSPECTOR_EXPORT
 #ifdef _MSC_VER
@@ -122,7 +123,13 @@ class RuntimeTargetDelegate {
  */
 class RuntimeTargetController {
  public:
-  enum class Domain { Network, Runtime, Log, kMaxValue };
+  enum class Domain {
+    Log,
+    Network,
+    ReactNativeApplication,
+    Runtime,
+    kMaxValue
+  };
 
   explicit RuntimeTargetController(RuntimeTarget& target);
 
@@ -347,6 +354,22 @@ class JSINSPECTOR_EXPORT RuntimeTarget
       bool enabled,
       const RuntimeAgent& notifyingAgent);
 
+  /**
+   * Processes the changes to the state of a given domain.
+   *
+   * Returns a pair of booleans:
+   *   1. Returns true, if an only if the given domain state changed locally,
+   *   for a given session.
+   *   2. Returns true, if and only if the given domain state changed globally:
+   *   when the given Agent is the only Agent that enabled given domain across
+   *   sessions, or when the only Agent that had this domain enabled has
+   *   disconnected.
+   */
+  std::pair<bool, bool> processDomainChange(
+      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