react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -36,8 +36,9 @@ const uint16_t HERMES_SAMPLING_FREQUENCY_HZ = 10000;
 class HermesRuntimeSamplingProfileDelegate {
  public:
   explicit HermesRuntimeSamplingProfileDelegate(
-      std::shared_ptr<HermesRuntime> hermesRuntime)
-      : hermesRuntime_(std::move(hermesRuntime)) {}
+      std::shared_ptr<jsi::Runtime> runtime,
+      hermes::HermesRuntime& hermesRuntime)
+      : runtime_(std::move(runtime)), hermesRuntime_(hermesRuntime) {}
 
   void startSampling() {
     auto* hermesAPI = jsi::castInterface<IHermesRootAPI>(makeHermesRootAPI());
@@ -52,11 +53,12 @@ class HermesRuntimeSamplingProfileDelegate {
   tracing::RuntimeSamplingProfile collectSamplingProfile() {
     return tracing::HermesRuntimeSamplingProfileSerializer::
         serializeToTracingSamplingProfile(
-            hermesRuntime_->dumpSampledTraceToProfile());
+            hermesRuntime_.dumpSampledTraceToProfile());
   }
 
  private:
-  std::shared_ptr<HermesRuntime> hermesRuntime_;
+  std::shared_ptr<jsi::Runtime> runtime_;
+  HermesRuntime& hermesRuntime_;
 };
 
 } // namespace
@@ -93,13 +95,16 @@ class HermesRuntimeTargetDelegate::Impl final : public RuntimeTargetDelegate {
  public:
   explicit Impl(
       HermesRuntimeTargetDelegate& delegate,
-      std::shared_ptr<HermesRuntime> hermesRuntime)
+      std::shared_ptr<jsi::Runtime> runtime,
+      HermesRuntime& hermesRuntime)
       : delegate_(delegate),
-        runtime_(hermesRuntime),
-        cdpDebugAPI_(CDPDebugAPI::create(*runtime_)),
+        runtime_(runtime),
+        hermesRuntime_(hermesRuntime),
+        cdpDebugAPI_(CDPDebugAPI::create(hermesRuntime_)),
         samplingProfileDelegate_(
             std::make_unique<HermesRuntimeSamplingProfileDelegate>(
-                std::move(hermesRuntime))) {}
+                std::move(runtime),
+                hermesRuntime_)) {}
 
   CDPDebugAPI& getCDPDebugAPI() {
     return *cdpDebugAPI_;
@@ -119,7 +124,7 @@ class HermesRuntimeTargetDelegate::Impl final : public RuntimeTargetDelegate {
         sessionState,
         std::move(previouslyExportedState),
         executionContextDescription,
-        *runtime_,
+        hermesRuntime_,
         delegate_,
         std::move(runtimeExecutor)));
   }
@@ -209,7 +214,7 @@ class HermesRuntimeTargetDelegate::Impl final : public RuntimeTargetDelegate {
     // properly representing the stack trace in other use cases, where native
     // frames aren't stripped on serialisation.
     return std::make_unique<HermesStackTraceWrapper>(
-        runtime_->getDebugger().captureStackTrace());
+        hermesRuntime_.getDebugger().captureStackTrace());
   }
 
   void enableSamplingProfiler() override {
@@ -267,7 +272,8 @@ class HermesRuntimeTargetDelegate::Impl final : public RuntimeTargetDelegate {
 
  private:
   HermesRuntimeTargetDelegate& delegate_;
-  std::shared_ptr<HermesRuntime> runtime_;
+  std::shared_ptr<jsi::Runtime> runtime_;
+  HermesRuntime& hermesRuntime_;
   const std::unique_ptr<CDPDebugAPI> cdpDebugAPI_;
   std::unique_ptr<HermesRuntimeSamplingProfileDelegate>
       samplingProfileDelegate_;
@@ -284,11 +290,13 @@ class HermesRuntimeTargetDelegate::Impl final
  public:
   explicit Impl(
       HermesRuntimeTargetDelegate&,
-      std::shared_ptr<HermesRuntime> hermesRuntime)
-      : FallbackRuntimeTargetDelegate{hermesRuntime->description()},
+      std::shared_ptr<jsi::Runtime> runtime,
+      HermesRuntime& hermesRuntime)
+      : FallbackRuntimeTargetDelegate{hermesRuntime.description()},
         samplingProfileDelegate_(
             std::make_unique<HermesRuntimeSamplingProfileDelegate>(
-                std::move(hermesRuntime))) {}
+                std::move(runtime),
+                hermesRuntime)) {}
 
   void enableSamplingProfiler() override {
     samplingProfileDelegate_->startSampling();
@@ -310,8 +318,9 @@ class HermesRuntimeTargetDelegate::Impl final
 #endif // HERMES_ENABLE_DEBUGGER
 
 HermesRuntimeTargetDelegate::HermesRuntimeTargetDelegate(
-    std::shared_ptr<HermesRuntime> hermesRuntime)
-    : impl_(std::make_unique<Impl>(*this, std::move(hermesRuntime))) {}
+    std::shared_ptr<jsi::Runtime> runtime,
+    HermesRuntime& hermesRuntime)
+    : impl_(std::make_unique<Impl>(*this, std::move(runtime), hermesRuntime)) {}
 
 HermesRuntimeTargetDelegate::~HermesRuntimeTargetDelegate() = default;
 

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

@@ -29,7 +29,7 @@ class HermesRuntimeTargetDelegate : public RuntimeTargetDelegate {
   /**
    * Creates a HermesRuntimeTargetDelegate for the given runtime.
    */
-  explicit HermesRuntimeTargetDelegate(std::shared_ptr<hermes::HermesRuntime> hermesRuntime);
+  explicit HermesRuntimeTargetDelegate(std::shared_ptr<jsi::Runtime> runtime, hermes::HermesRuntime &hermesRuntime);
 
   ~HermesRuntimeTargetDelegate() override;
 

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -236,13 +236,11 @@ class HostAgent::Impl final {
         emitSystemStateChanged(isSingleHost);
       }
 
-      auto stashedTraceRecording =
-          targetController_.getDelegate()
-              .unstable_getHostTracingProfileThatWillBeEmittedOnInitialization();
-      if (stashedTraceRecording.has_value()) {
-        tracingAgent_.emitExternalHostTracingProfile(
-            std::move(stashedTraceRecording.value()));
-      }
+      auto emitted = targetController_.maybeEmitStashedBackgroundTrace();
+      assert(
+          emitted &&
+          "Expected to find at least one session eligible to receive a background trace after ReactNativeApplication.enable");
+      (void)emitted;
 
       return {
           .isFinishedHandlingRequest = true,
@@ -381,16 +379,8 @@ class HostAgent::Impl final {
     }
   }
 
-  bool hasFuseboxClientConnected() const {
-    return fuseboxClientType_ == FuseboxClientType::Fusebox;
-  }
-
-  void emitExternalTracingProfile(
-      tracing::HostTracingProfile tracingProfile) const {
-    assert(
-        hasFuseboxClientConnected() &&
-        "Attempted to emit a trace recording to a non-Fusebox client");
-    tracingAgent_.emitExternalHostTracingProfile(std::move(tracingProfile));
+  bool isEligibleForBackgroundTrace() const {
+    return sessionState_.isReactNativeApplicationDomainEnabled;
   }
 
   void emitSystemStateChanged(bool isSingleHost) {
@@ -503,10 +493,9 @@ class HostAgent::Impl final {
 
   void handleRequest(const cdp::PreparsedRequest& req) {}
   void setCurrentInstanceAgent(std::shared_ptr<InstanceAgent> agent) {}
-  bool hasFuseboxClientConnected() const {
+  bool isEligibleForBackgroundTrace() const {
     return false;
   }
-  void emitExternalTracingProfile(tracing::HostTracingProfile tracingProfile) {}
   void emitSystemStateChanged(bool isSingleHost) {}
 };
 
@@ -538,17 +527,8 @@ void HostAgent::setCurrentInstanceAgent(
   impl_->setCurrentInstanceAgent(std::move(instanceAgent));
 }
 
-bool HostAgent::hasFuseboxClientConnected() const {
-  return impl_->hasFuseboxClientConnected();
-}
-
-void HostAgent::emitExternalTracingProfile(
-    tracing::HostTracingProfile tracingProfile) const {
-  impl_->emitExternalTracingProfile(std::move(tracingProfile));
-}
-
-void HostAgent::emitSystemStateChanged(bool isSingleHost) const {
-  impl_->emitSystemStateChanged(isSingleHost);
+bool HostAgent::isEligibleForBackgroundTrace() const {
+  return impl_->isEligibleForBackgroundTrace();
 }
 
 #pragma mark - Tracing

package/ReactCommon/jsinspector-modern/HostAgent.h

@@ -67,23 +67,16 @@ class HostAgent final {
   void setCurrentInstanceAgent(std::shared_ptr<InstanceAgent> agent);
 
   /**
-   * Returns whether this HostAgent is part of the session that has an active
-   * Fusebox client connecte, i.e. with Chrome DevTools Frontend fork for React
-   * Native.
+   * Returns whether this HostAgent is eligible to receive notifications about
+   * background traces.
    */
-  bool hasFuseboxClientConnected() const;
-
-  /**
-   * Emits the HostTracingProfile that was captured externally, not via the
-   * CDP-initiated request.
-   */
-  void emitExternalTracingProfile(tracing::HostTracingProfile tracingProfile) const;
+  bool isEligibleForBackgroundTrace() const;
 
   /**
    * Emits a system state changed event when the number of ReactHost instances
    * changes.
    */
-  void emitSystemStateChanged(bool isSingleHost) const;
+  void emitSystemStateChanged(bool isSingleHost);
 
  private:
   // We use the private implementation idiom to ensure this class has the same

package/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -8,6 +8,7 @@
 #include "HostTarget.h"
 #include "HostAgent.h"
 #include "HostTargetTraceRecording.h"
+#include "HostTargetTracing.h"
 #include "InspectorInterfaces.h"
 #include "InspectorUtilities.h"
 #include "InstanceTarget.h"
@@ -102,18 +103,12 @@ class HostTargetSession {
     }
   }
 
-  /**
-   * Returns whether the ReactNativeApplication CDP domain is enabled.
-   *
-   * Chrome DevTools Frontend enables this domain as a client.
-   */
-  bool hasFuseboxClient() const {
-    return hostAgent_.hasFuseboxClientConnected();
+  HostAgent& agent() {
+    return hostAgent_;
   }
 
-  void emitHostTracingProfile(
-      tracing::HostTracingProfile tracingProfile) const {
-    hostAgent_.emitExternalTracingProfile(std::move(tracingProfile));
+  FrontendChannel dangerouslyGetFrontendChannel() {
+    return frontendChannel_;
   }
 
  private:
@@ -324,6 +319,10 @@ bool HostTargetController::decrementPauseOverlayCounter() {
   return --pauseOverlayCounter_ != 0;
 }
 
+bool HostTargetController::maybeEmitStashedBackgroundTrace() {
+  return target_.maybeEmitStashedBackgroundTrace();
+}
+
 namespace {
 
 struct StaticHostTargetMetadata {
@@ -375,32 +374,33 @@ folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata) {
   return result;
 }
 
-bool HostTarget::hasActiveSessionWithFuseboxClient() const {
-  bool hasActiveFuseboxSession = false;
-  sessions_.forEach([&](HostTargetSession& session) {
-    hasActiveFuseboxSession |= session.hasFuseboxClient();
+bool HostTarget::maybeEmitStashedBackgroundTrace() {
+  std::vector<FrontendChannel> eligibleFrontendChannels;
+  eligibleFrontendChannels.reserve(sessions_.size());
+  sessions_.forEach([&eligibleFrontendChannels](auto& session) {
+    if (session.agent().isEligibleForBackgroundTrace()) {
+      eligibleFrontendChannels.push_back(
+          session.dangerouslyGetFrontendChannel());
+    }
   });
-  return hasActiveFuseboxSession;
+
+  if (eligibleFrontendChannels.empty()) {
+    return false;
+  }
+
+  auto stashedTrace = std::exchange(stashedTracingProfile_, std::nullopt);
+  if (stashedTrace) {
+    emitNotificationsForTracingProfile(
+        std::move(*stashedTrace),
+        eligibleFrontendChannels,
+        /* isBackgroundTrace */ true);
+  }
+  return true;
 }
 
-void HostTarget::emitTracingProfileForFirstFuseboxClient(
-    tracing::HostTracingProfile tracingProfile) const {
-  bool emitted = false;
-  sessions_.forEach([&](HostTargetSession& session) {
-    if (emitted) {
-      /**
-       * HostTracingProfile object is not copiable for performance reasons,
-       * because it could contain large Runtime sampling profile object.
-       *
-       * This approach would not work with multi-client debugger setup.
-       */
-      return;
-    }
-    if (session.hasFuseboxClient()) {
-      session.emitHostTracingProfile(std::move(tracingProfile));
-      emitted = true;
-    }
-  });
+bool HostTarget::stopAndMaybeEmitBackgroundTrace() {
+  stashedTracingProfile_ = stopTracing();
+  return maybeEmitStashedBackgroundTrace();
 }
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostTarget.h

@@ -181,19 +181,6 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
         "LoadNetworkResourceDelegate.loadNetworkResource is not implemented by this host target delegate.");
   }
 
-  /**
-   * [Experimental] Will be called at the CDP session initialization to get the
-   * trace recording that may have been stashed by the Host from the previous
-   * background session.
-   *
-   * \return the HostTracingProfile if there is one that needs to be
-   * displayed, otherwise std::nullopt.
-   */
-  virtual std::optional<tracing::HostTracingProfile> unstable_getHostTracingProfileThatWillBeEmittedOnInitialization()
-  {
-    return std::nullopt;
-  }
-
   /**
    * An optional delegate that will be used by HostTarget to notify about tracing-related events.
    */
@@ -256,6 +243,12 @@ class HostTargetController final {
    */
   tracing::HostTracingProfile stopTracing();
 
+  /**
+   * If there is a stashed background trace, emit it to all eligible sessions.
+   * \return true if an eligible session is found (even if there was no stashed background trace).
+   */
+  bool maybeEmitStashedBackgroundTrace();
+
  private:
   HostTarget &target_;
   size_t pauseOverlayCounter_{0};
@@ -352,18 +345,13 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
   tracing::HostTracingProfile stopTracing();
 
   /**
-   * Returns whether there is an active session with the Fusebox client, i.e.
-   * with Chrome DevTools Frontend fork for React Native.
+   * Stops previously started trace recording and:
+   *  - If there is an active CDP session with ReactNativeApplication domain
+   *    enabled, emits the trace and returns true.
+   *  - Otherwise, stashes the captured trace, that will be emitted when a CDP
+   *    session enables ReactNativeApplication. Returns false.
    */
-  bool hasActiveSessionWithFuseboxClient() const;
-
-  /**
-   * Emits the HostTracingProfile for the first active session with the Fusebox
-   * client.
-   *
-   * @see \c hasActiveFrontendSession
-   */
-  void emitTracingProfileForFirstFuseboxClient(tracing::HostTracingProfile tracingProfile) const;
+  bool stopAndMaybeEmitBackgroundTrace();
 
   /**
    * An endpoint for the Host to report frame timings that will be recorded if and only if there is currently an active
@@ -403,6 +391,11 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
    * Should only be allocated when there is an active tracing session.
    */
   std::unique_ptr<HostTargetTraceRecording> traceRecording_{nullptr};
+  /**
+   * Previously recorded HostTracingProfile that will be emitted when CDP session is created
+   * and enables ReactNativeApplication. Once emitted, the value will be cleared.
+   */
+  std::optional<tracing::HostTracingProfile> stashedTracingProfile_;
   /**
    * Protects the state inside traceRecording_.
    *
@@ -429,6 +422,12 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
    */
   void installPerfIssuesBinding();
 
+  /**
+   * If there is a stashed background trace, emit it to the first eligible session.
+   * \return true if an eligible session is found (even if there was no stashed background trace).
+   */
+  bool maybeEmitStashedBackgroundTrace();
+
   // Necessary to allow HostAgent to access HostTarget's internals in a
   // controlled way (i.e. only HostTargetController gets friend access, while
   // HostAgent itself doesn't).

package/ReactCommon/jsinspector-modern/HostTargetTraceRecording.cpp

@@ -23,8 +23,7 @@ HostTargetTraceRecording::HostTargetTraceRecording(
       windowSize_(windowSize) {
   if (windowSize) {
     frameTimings_ = tracing::TimeWindowedBuffer<tracing::FrameTimingSequence>(
-        [](auto& sequence) { return sequence.beginDrawingTimestamp; },
-        *windowSize);
+        [](auto& sequence) { return sequence.beginTimestamp; }, *windowSize);
   } else {
     frameTimings_ = tracing::TimeWindowedBuffer<tracing::FrameTimingSequence>();
   };

package/ReactCommon/jsinspector-modern/HostTargetTracing.h

@@ -0,0 +1,89 @@
+/*
+ * 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 "InspectorInterfaces.h"
+
+#include "cdp/CdpJson.h"
+#include "tracing/HostTracingProfile.h"
+#include "tracing/HostTracingProfileSerializer.h"
+
+#include <array>
+#include <concepts>
+#include <cstdint>
+#include <ranges>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Emits a captured HostTracingProfile in a series of
+ * Tracing.dataCollected events, followed by a Tracing.tracingComplete event, to zero or more
+ * FrontendChannels. If \p isBackgroundTrace is true, a ReactNativeApplication.traceRequested
+ * notification is sent to each FrontendChannel before the trace events are emitted.
+ */
+template <typename ChannelsRange>
+void emitNotificationsForTracingProfile(
+    tracing::HostTracingProfile &&hostTracingProfile,
+    const ChannelsRange &channels,
+    bool isBackgroundTrace)
+  requires std::ranges::range<ChannelsRange> &&
+    std::convertible_to<std::ranges::range_value_t<ChannelsRange>, FrontendChannel>
+{
+  /**
+   * Threshold for the size Trace Event chunk, that will be flushed out with
+   * Tracing.dataCollected event.
+   */
+  static constexpr uint16_t TRACE_EVENT_CHUNK_SIZE = 1000;
+
+  /**
+   * The maximum number of ProfileChunk trace events
+   * that will be sent in a single CDP Tracing.dataCollected message.
+   */
+  static constexpr uint16_t PROFILE_TRACE_EVENT_CHUNK_SIZE = 10;
+
+  if (std::ranges::empty(channels)) {
+    return;
+  }
+
+  if (isBackgroundTrace) {
+    for (auto &frontendChannel : channels) {
+      frontendChannel(cdp::jsonNotification("ReactNativeApplication.traceRequested"));
+    }
+  }
+
+  // Serialize each chunk once and send it to all eligible sessions.
+  tracing::HostTracingProfileSerializer::emitAsDataCollectedChunks(
+      std::move(hostTracingProfile),
+      [&](folly::dynamic &&serializedChunk) {
+        for (auto &frontendChannel : channels) {
+          frontendChannel(
+              cdp::jsonNotification("Tracing.dataCollected", folly::dynamic::object("value", serializedChunk)));
+        }
+      },
+      TRACE_EVENT_CHUNK_SIZE,
+      PROFILE_TRACE_EVENT_CHUNK_SIZE);
+
+  for (auto &frontendChannel : channels) {
+    frontendChannel(
+        cdp::jsonNotification("Tracing.tracingComplete", folly::dynamic::object("dataLossOccurred", false)));
+  }
+}
+
+/**
+ * Convenience overload of emitNotificationsForTracingProfile() for a single FrontendChannel.
+ */
+inline void emitNotificationsForTracingProfile(
+    tracing::HostTracingProfile &&hostTracingProfile,
+    const FrontendChannel &channel,
+    bool isBackgroundTrace)
+{
+  std::array<FrontendChannel, 1> channels{channel};
+  emitNotificationsForTracingProfile(std::move(hostTracingProfile), channels, isBackgroundTrace);
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InspectorInterfaces.cpp

@@ -29,8 +29,7 @@ folly::dynamic targetCapabilitiesToDynamic(
     const InspectorTargetCapabilities& capabilities) {
   return folly::dynamic::object(
       "nativePageReloads", capabilities.nativePageReloads)(
-      "nativeSourceCodeFetching", capabilities.nativeSourceCodeFetching)(
-      "prefersFuseboxFrontend", capabilities.prefersFuseboxFrontend);
+      "nativeSourceCodeFetching", capabilities.nativeSourceCodeFetching);
 }
 
 namespace {
@@ -143,13 +142,9 @@ int InspectorImpl::addPage(
       pageId,
       Page{pageId, description, vm, std::move(connectFunc), capabilities});
 
-  // Strong assumption: If prefersFuseboxFrontend is set, the page added is a
-  // HostTarget and not a legacy Hermes runtime target.
-  if (capabilities.prefersFuseboxFrontend) {
-    for (const auto& listenerWeak : listeners_) {
-      if (auto listener = listenerWeak.lock()) {
-        listener->unstable_onHostTargetAdded();
-      }
+  for (const auto& listenerWeak : listeners_) {
+    if (auto listener = listenerWeak.lock()) {
+      listener->unstable_onHostTargetAdded();
     }
   }
 

package/ReactCommon/jsinspector-modern/InspectorInterfaces.h

@@ -36,7 +36,6 @@ class IDestructible {
 struct InspectorTargetCapabilities {
   bool nativePageReloads = false;
   bool nativeSourceCodeFetching = false;
-  bool prefersFuseboxFrontend = false;
 };
 
 folly::dynamic targetCapabilitiesToDynamic(const InspectorTargetCapabilities &capabilities);