react-native-tvos 0.74.3-0 → 0.75.2-0

package/ReactCommon/hermes/executor/HermesExecutorFactory.cpp

@@ -7,15 +7,13 @@
 
 #include "HermesExecutorFactory.h"
 
-#include <thread>
-
 #include <cxxreact/MessageQueueThread.h>
 #include <cxxreact/SystraceSection.h>
 #include <hermes/hermes.h>
 #include <jsi/decorator.h>
 #include <jsinspector-modern/InspectorFlags.h>
 
-#include <hermes/inspector-modern/chrome/HermesRuntimeAgentDelegate.h>
+#include <hermes/inspector-modern/chrome/HermesRuntimeTargetDelegate.h>
 #include <hermes/inspector-modern/chrome/Registration.h>
 #include <hermes/inspector/RuntimeAdapter.h>
 
@@ -155,6 +153,8 @@ class DecoratedRuntime : public jsi::WithRuntimeDecorator<ReentrancyCheck> {
       debugToken_ = facebook::hermes::inspector_modern::chrome::enableDebugging(
           std::move(adapter), debuggerName);
     }
+#else
+    (void)jsQueue;
 #endif // HERMES_ENABLE_DEBUGGER
   }
 
@@ -203,8 +203,7 @@ std::unique_ptr<JSExecutor> HermesExecutorFactory::createJSExecutor(
 
   HermesRuntime& hermesRuntimeRef = *hermesRuntime;
   auto& inspectorFlags = jsinspector_modern::InspectorFlags::getInstance();
-  bool enableDebugger =
-      !inspectorFlags.getEnableModernCDPRegistry() && enableDebugger_;
+  bool enableDebugger = !inspectorFlags.getFuseboxEnabled() && enableDebugger_;
   auto decoratedRuntime = std::make_shared<DecoratedRuntime>(
       std::move(hermesRuntime),
       hermesRuntimeRef,
@@ -253,40 +252,17 @@ HermesExecutor::HermesExecutor(
     RuntimeInstaller runtimeInstaller,
     HermesRuntime& hermesRuntime)
     : JSIExecutor(runtime, delegate, timeoutInvoker, runtimeInstaller),
-      jsQueue_(jsQueue),
       runtime_(runtime),
-      hermesRuntime_(hermesRuntime) {}
-
-std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate>
-HermesExecutor::createAgentDelegate(
-    jsinspector_modern::FrontendChannel frontendChannel,
-    jsinspector_modern::SessionState& sessionState,
-    std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate::ExportedState>
-        previouslyExportedState,
-    const jsinspector_modern::ExecutionContextDescription&
-        executionContextDescription) {
-  std::shared_ptr<HermesRuntime> hermesRuntimeShared(runtime_, &hermesRuntime_);
-  return std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate>(
-      new jsinspector_modern::HermesRuntimeAgentDelegate(
-          frontendChannel,
-          sessionState,
-          std::move(previouslyExportedState),
-          executionContextDescription,
-          hermesRuntimeShared,
-          [jsQueueWeak = std::weak_ptr(jsQueue_),
-           runtimeWeak = std::weak_ptr(runtime_)](auto fn) {
-            auto jsQueue = jsQueueWeak.lock();
-            if (!jsQueue) {
-              return;
-            }
-            jsQueue->runOnQueue([runtimeWeak, fn]() {
-              auto runtime = runtimeWeak.lock();
-              if (!runtime) {
-                return;
-              }
-              fn(*runtime);
-            });
-          }));
+      hermesRuntime_(runtime_, &hermesRuntime) {}
+
+jsinspector_modern::RuntimeTargetDelegate&
+HermesExecutor::getRuntimeTargetDelegate() {
+  if (!targetDelegate_) {
+    targetDelegate_ =
+        std::make_unique<jsinspector_modern::HermesRuntimeTargetDelegate>(
+            hermesRuntime_);
+  }
+  return *targetDelegate_;
 }
 
 } // namespace facebook::react

package/ReactCommon/hermes/executor/HermesExecutorFactory.h

@@ -54,20 +54,14 @@ class HermesExecutor : public JSIExecutor {
       RuntimeInstaller runtimeInstaller,
       hermes::HermesRuntime& hermesRuntime);
 
-  virtual std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate>
-  createAgentDelegate(
-      jsinspector_modern::FrontendChannel frontendChannel,
-      jsinspector_modern::SessionState& sessionState,
-      std::unique_ptr<jsinspector_modern::RuntimeAgentDelegate::ExportedState>
-          previouslyExportedState,
-      const jsinspector_modern::ExecutionContextDescription&
-          executionContextDescription) override;
+  jsinspector_modern::RuntimeTargetDelegate& getRuntimeTargetDelegate()
+      override;
 
  private:
   JSIScopedTimeoutInvoker timeoutInvoker_;
-  std::shared_ptr<MessageQueueThread> jsQueue_;
   std::shared_ptr<jsi::Runtime> runtime_;
-  hermes::HermesRuntime& hermesRuntime_;
+  std::shared_ptr<hermes::HermesRuntime> hermesRuntime_;
+  std::unique_ptr<jsinspector_modern::RuntimeTargetDelegate> targetDelegate_;
 };
 
 } // namespace facebook::react

package/ReactCommon/hermes/executor/React-jsitracing.podspec

@@ -29,7 +29,7 @@ Pod::Spec.new do |s|
   s.header_dir             = "."
   s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"${PODS_TARGET_SRCROOT}/../..\"",
                                 "USE_HEADERMAP" => "YES",
-                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+                                "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                 "GCC_WARN_PEDANTIC" => "YES" }
 
   if ENV['USE_FRAMEWORKS']

package/ReactCommon/hermes/inspector-modern/chrome/HermesRuntimeAgentDelegate.cpp

@@ -5,18 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "HermesRuntimeAgentDelegate.h"
-
-// If HERMES_ENABLE_DEBUGGER isn't defined, we can't access any Hermes
-// CDPHandler headers or types.
-
 #ifdef HERMES_ENABLE_DEBUGGER
-#include <hermes/inspector/RuntimeAdapter.h>
-#include <hermes/inspector/chrome/CDPHandler.h>
-#else // HERMES_ENABLE_DEBUGGER
-#include <jsinspector-modern/FallbackRuntimeAgentDelegate.h>
-#endif // HERMES_ENABLE_DEBUGGER
 
+#include "HermesRuntimeAgentDelegate.h"
+
+#include <hermes/AsyncDebuggerAPI.h>
+#include <hermes/cdp/CDPAgent.h>
 #include <hermes/hermes.h>
 #include <jsinspector-modern/ReactCdp.h>
 
@@ -24,195 +18,97 @@ using namespace facebook::hermes;
 
 namespace facebook::react::jsinspector_modern {
 
-#ifdef HERMES_ENABLE_DEBUGGER
-
-namespace {
-
-/**
- * An implementation of the Hermes RuntimeAdapter interface (part of
- * Hermes's CDPHandler API) for use within a React Native RuntimeAgentDelegate.
- */
-class HermesRuntimeAgentDelegateAdapter
-    : public hermes::inspector_modern::RuntimeAdapter {
- public:
-  HermesRuntimeAgentDelegateAdapter(
-      std::shared_ptr<hermes::HermesRuntime> runtime,
-      RuntimeExecutor runtimeExecutor)
-      : runtime_(runtime), runtimeExecutor_(runtimeExecutor) {}
-
-  HermesRuntime& getRuntime() override {
-    return *runtime_;
-  }
-
-  void tickleJs() override {
-    runtimeExecutor_([](jsi::Runtime& runtime) {
-      jsi::Function func =
-          runtime.global().getPropertyAsFunction(runtime, "__tickleJs");
-      func.call(runtime);
-    });
-  }
-
- private:
-  std::shared_ptr<hermes::HermesRuntime> runtime_;
-  RuntimeExecutor runtimeExecutor_;
-};
-
-} // namespace
-
-/**
- * A RuntimeAgentDelegate that handles requests from the Chrome DevTools
- * Protocol for an instance of Hermes.
- */
 class HermesRuntimeAgentDelegate::Impl final : public RuntimeAgentDelegate {
-  using HermesCDPHandler = hermes::inspector_modern::chrome::CDPHandler;
-  using HermesExecutionContextDescription =
-      hermes::inspector_modern::chrome::CDPHandlerExecutionContextDescription;
-  using HermesState = hermes::inspector_modern::chrome::State;
+  using HermesState = hermes::cdp::State;
 
   struct HermesStateWrapper : public ExportedState {
-    explicit HermesStateWrapper(std::unique_ptr<HermesState> state)
-        : state_(std::move(state)) {}
+    explicit HermesStateWrapper(HermesState state) : state_(std::move(state)) {}
 
-    static std::unique_ptr<HermesState> unwrapDestructively(
-        ExportedState* wrapper) {
+    static HermesState unwrapDestructively(ExportedState* wrapper) {
       if (!wrapper) {
-        return nullptr;
+        return {};
       }
       if (auto* typedWrapper = dynamic_cast<HermesStateWrapper*>(wrapper)) {
         return std::move(typedWrapper->state_);
       }
-      return nullptr;
+      return {};
     }
 
    private:
-    std::unique_ptr<HermesState> state_;
+    HermesState state_;
   };
 
  public:
-  /**
-   * \param frontendChannel A channel used to send responses and events to the
-   * frontend.
-   * \param sessionState The state of the current CDP session. This will only
-   * be accessed on the main thread (during the constructor, in handleRequest,
-   * etc).
-   * \param previouslyExportedState The exported state from a previous instance
-   * of RuntimeAgentDelegate (NOT necessarily HermesRuntimeAgentDelegate). This
-   * may be nullptr, and if not nullptr it may be of any concrete type that
-   * implements RuntimeAgentDelegate::ExportedState.
-   * \param executionContextDescription A description of the execution context
-   * represented by this runtime. This is used for disambiguating the
-   * source/destination of CDP messages when there are multiple runtimes
-   * (concurrently or over the life of a Page).
-   * \param runtime The HermesRuntime that this agent is attached to.
-   * \param runtimeExecutor A callback for scheduling work on the JS thread.
-   * \c runtimeExecutor may drop scheduled work if the runtime is destroyed
-   * first.
-   */
   Impl(
       FrontendChannel frontendChannel,
       SessionState& sessionState,
       std::unique_ptr<RuntimeAgentDelegate::ExportedState>
           previouslyExportedState,
       const ExecutionContextDescription& executionContextDescription,
-      std::shared_ptr<hermes::HermesRuntime> runtime,
-      RuntimeExecutor runtimeExecutor)
-      : hermes_(HermesCDPHandler::create(
-            std::make_unique<HermesRuntimeAgentDelegateAdapter>(
-                runtime,
-                runtimeExecutor),
-            /* waitForDebugger */ false,
-            /* enableConsoleAPICapturing */ false,
-            /* state */
+      HermesRuntime& runtime,
+      HermesRuntimeTargetDelegate& runtimeTargetDelegate,
+      const RuntimeExecutor& runtimeExecutor)
+      : hermes_(hermes::cdp::CDPAgent::create(
+            executionContextDescription.id,
+            runtimeTargetDelegate.getCDPDebugAPI(),
+            // RuntimeTask takes a HermesRuntime whereas our RuntimeExecutor
+            // takes a jsi::Runtime.
+            [runtimeExecutor,
+             &runtime](facebook::hermes::debugger::RuntimeTask fn) {
+              runtimeExecutor(
+                  [&runtime, fn = std::move(fn)](auto&) { fn(runtime); });
+            },
+            frontendChannel,
             HermesStateWrapper::unwrapDestructively(
-                previouslyExportedState.get()),
-            {.isRuntimeDomainEnabled = sessionState.isRuntimeDomainEnabled},
-            HermesExecutionContextDescription{
-                .id = executionContextDescription.id,
-                .origin = executionContextDescription.origin,
-                .name = executionContextDescription.name,
-                .auxData = std::nullopt,
-                .shouldSendNotifications = false})) {
-    hermes_->registerCallbacks(
-        /* msgCallback */
-        [frontendChannel =
-             std::move(frontendChannel)](const std::string& messageFromHermes) {
-          frontendChannel(messageFromHermes);
-          ;
-        },
-        /* onUnregister */
-        []() {});
+                previouslyExportedState.get()))) {
+    if (sessionState.isRuntimeDomainEnabled) {
+      hermes_->enableRuntimeDomain();
+    }
+    if (sessionState.isDebuggerDomainEnabled) {
+      hermes_->enableDebuggerDomain();
+    }
   }
 
-  /**
-   * Handle a CDP request.  The response will be sent over the provided
-   * \c FrontendChannel synchronously or asynchronously.
-   * \param req The parsed request.
-   * \returns true if this agent has responded, or will respond asynchronously,
-   * to the request (with either a success or error message). False if the
-   * agent expects another agent to respond to the request instead.
-   */
   bool handleRequest(const cdp::PreparsedRequest& req) override {
     // TODO: Change to string::starts_with when we're on C++20.
     if (req.method.rfind("Log.", 0) == 0) {
-      // Since we know Hermes doesn't do anything useful with Log messages, but
-      // our containing PageAgent will, just bail out early.
+      // Since we know Hermes doesn't do anything useful with Log messages,
+      // but our containing HostAgent will, bail out early.
       // TODO: We need a way to negotiate this more dynamically with Hermes
       // through the API.
       return false;
     }
-    // Forward everything else to Hermes's CDPHandler.
-    hermes_->handle(req.toJson());
+    // Forward everything else to Hermes's CDPAgent.
+    hermes_->handleCommand(req.toJson());
     // Let the call know that this request is handled (i.e. it is Hermes's
     // responsibility to respond with either success or an error).
     return true;
   }
 
-  virtual std::unique_ptr<ExportedState> getExportedState() override {
+  std::unique_ptr<ExportedState> getExportedState() override {
     return std::make_unique<HermesStateWrapper>(hermes_->getState());
   }
 
  private:
-  std::shared_ptr<HermesCDPHandler> hermes_;
+  std::unique_ptr<hermes::cdp::CDPAgent> hermes_;
 };
 
-#else // !HERMES_ENABLE_DEBUGGER
-
-/**
- * A stub for HermesRuntimeAgentDelegate when Hermes is compiled without
- * debugging support.
- */
-class HermesRuntimeAgentDelegate::Impl final
-    : public FallbackRuntimeAgentDelegate {
- public:
-  Impl(
-      FrontendChannel frontendChannel,
-      SessionState& sessionState,
-      std::unique_ptr<RuntimeAgentDelegate::ExportedState>,
-      const ExecutionContextDescription&,
-      std::shared_ptr<hermes::HermesRuntime> runtime,
-      RuntimeExecutor)
-      : FallbackRuntimeAgentDelegate(
-            std::move(frontendChannel),
-            sessionState,
-            runtime->description()) {}
-};
-
-#endif // HERMES_ENABLE_DEBUGGER
-
 HermesRuntimeAgentDelegate::HermesRuntimeAgentDelegate(
     FrontendChannel frontendChannel,
     SessionState& sessionState,
     std::unique_ptr<RuntimeAgentDelegate::ExportedState>
         previouslyExportedState,
     const ExecutionContextDescription& executionContextDescription,
-    std::shared_ptr<hermes::HermesRuntime> runtime,
+    HermesRuntime& runtime,
+    HermesRuntimeTargetDelegate& runtimeTargetDelegate,
     RuntimeExecutor runtimeExecutor)
     : impl_(std::make_unique<Impl>(
           std::move(frontendChannel),
           sessionState,
           std::move(previouslyExportedState),
           executionContextDescription,
-          std::move(runtime),
+          runtime,
+          runtimeTargetDelegate,
           std::move(runtimeExecutor))) {}
 
 bool HermesRuntimeAgentDelegate::handleRequest(
@@ -220,9 +116,11 @@ bool HermesRuntimeAgentDelegate::handleRequest(
   return impl_->handleRequest(req);
 }
 
-std::unique_ptr<HermesRuntimeAgentDelegate::ExportedState>
+std::unique_ptr<RuntimeAgentDelegate::ExportedState>
 HermesRuntimeAgentDelegate::getExportedState() {
   return impl_->getExportedState();
 }
 
 } // namespace facebook::react::jsinspector_modern
+
+#endif // HERMES_ENABLE_DEBUGGER

package/ReactCommon/hermes/inspector-modern/chrome/HermesRuntimeAgentDelegate.h

@@ -7,8 +7,11 @@
 
 #pragma once
 
-#include <ReactCommon/RuntimeExecutor.h>
+#ifdef HERMES_ENABLE_DEBUGGER
+
+#include "HermesRuntimeTargetDelegate.h"
 
+#include <ReactCommon/RuntimeExecutor.h>
 #include <hermes/hermes.h>
 #include <jsinspector-modern/ReactCdp.h>
 
@@ -16,7 +19,7 @@ namespace facebook::react::jsinspector_modern {
 
 /**
  * A RuntimeAgentDelegate that handles requests from the Chrome DevTools
- * Protocol for an instance of Hermes.
+ * Protocol for an instance of Hermes, using the modern CDPAgent API.
  */
 class HermesRuntimeAgentDelegate : public RuntimeAgentDelegate {
  public:
@@ -27,14 +30,18 @@ class HermesRuntimeAgentDelegate : public RuntimeAgentDelegate {
    * be accessed on the main thread (during the constructor, in handleRequest,
    * etc).
    * \param previouslyExportedState The exported state from a previous instance
-   * of RuntimeAgentDelegate (NOT necessarily HermesRuntimeAgentDelegate). This
-   * may be nullptr, and if not nullptr it may be of any concrete type that
+   * of RuntimeAgentDelegate (NOT necessarily HermesRuntimeAgentDelegate).
+   * This may be nullptr, and if not nullptr it may be of any concrete type that
    * implements RuntimeAgentDelegate::ExportedState.
    * \param executionContextDescription A description of the execution context
    * represented by this runtime. This is used for disambiguating the
    * source/destination of CDP messages when there are multiple runtimes
-   * (concurrently or over the life of a Page).
-   * \param runtime The HermesRuntime that this agent is attached to.
+   * (concurrently or over the life of a Host).
+   * \param runtime The HermesRuntime that this agent is attached to. The caller
+   * is responsible for keeping this object alive for the duration of the
+   * \c HermesRuntimeAgentDelegate lifetime.
+   * \param runtimeTargetDelegate The \c HermesRuntimeTargetDelegate object
+   * object for the passed runtime.
    * \param runtimeExecutor A callback for scheduling work on the JS thread.
    * \c runtimeExecutor may drop scheduled work if the runtime is destroyed
    * first.
@@ -45,11 +52,12 @@ class HermesRuntimeAgentDelegate : public RuntimeAgentDelegate {
       std::unique_ptr<RuntimeAgentDelegate::ExportedState>
           previouslyExportedState,
       const ExecutionContextDescription& executionContextDescription,
-      std::shared_ptr<hermes::HermesRuntime> runtime,
+      hermes::HermesRuntime& runtime,
+      HermesRuntimeTargetDelegate& runtimeTargetDelegate,
       RuntimeExecutor runtimeExecutor);
 
   /**
-   * Handle a CDP request.  The response will be sent over the provided
+   * Handle a CDP request. The response will be sent over the provided
    * \c FrontendChannel synchronously or asynchronously.
    * \param req The parsed request.
    * \returns true if this agent has responded, or will respond asynchronously,
@@ -58,14 +66,18 @@ class HermesRuntimeAgentDelegate : public RuntimeAgentDelegate {
    */
   bool handleRequest(const cdp::PreparsedRequest& req) override;
 
-  virtual std::unique_ptr<ExportedState> getExportedState() override;
+  std::unique_ptr<RuntimeAgentDelegate::ExportedState> getExportedState()
+      override;
 
  private:
-  // We use the private implementation idiom to keep HERMES_ENABLE_DEBUGGER
-  // checks out of the header.
   class Impl;
 
   const std::unique_ptr<Impl> impl_;
 };
 
 } // namespace facebook::react::jsinspector_modern
+
+#else
+#error \
+    "HERMES_ENABLE_DEBUGGER must be enabled to use HermesRuntimeAgentDelegate."
+#endif // HERMES_ENABLE_DEBUGGER