react-native 0.83.3 → 0.83.5

package/ReactCommon/jsinspector-modern/HostTarget.cpp

@@ -111,8 +111,9 @@ class HostTargetSession {
     return hostAgent_.hasFuseboxClientConnected();
   }
 
-  void emitTraceRecording(tracing::TraceRecordingState traceRecording) const {
-    hostAgent_.emitExternalTraceRecording(std::move(traceRecording));
+  void emitHostTracingProfile(
+      tracing::HostTracingProfile tracingProfile) const {
+    hostAgent_.emitExternalTracingProfile(std::move(tracingProfile));
   }
 
  private:
@@ -328,6 +329,7 @@ namespace {
 struct StaticHostTargetMetadata {
   std::optional<bool> isProfilingBuild;
   std::optional<bool> networkInspectionEnabled;
+  std::optional<bool> frameRecordingEnabled;
 };
 
 StaticHostTargetMetadata getStaticHostMetadata() {
@@ -335,7 +337,8 @@ StaticHostTargetMetadata getStaticHostMetadata() {
 
   return {
       .isProfilingBuild = inspectorFlags.getIsProfilingBuild(),
-      .networkInspectionEnabled = inspectorFlags.getNetworkInspectionEnabled()};
+      .networkInspectionEnabled = inspectorFlags.getNetworkInspectionEnabled(),
+      .frameRecordingEnabled = inspectorFlags.getFrameRecordingEnabled()};
 }
 
 } // namespace
@@ -370,6 +373,10 @@ folly::dynamic createHostMetadataPayload(const HostTargetMetadata& metadata) {
     result["unstable_networkInspectionEnabled"] =
         staticMetadata.networkInspectionEnabled.value();
   }
+  if (staticMetadata.frameRecordingEnabled) {
+    result["unstable_frameRecordingEnabled"] =
+        staticMetadata.frameRecordingEnabled.value();
+  }
 
   return result;
 }
@@ -382,13 +389,13 @@ bool HostTarget::hasActiveSessionWithFuseboxClient() const {
   return hasActiveFuseboxSession;
 }
 
-void HostTarget::emitTraceRecordingForFirstFuseboxClient(
-    tracing::TraceRecordingState traceRecording) const {
+void HostTarget::emitTracingProfileForFirstFuseboxClient(
+    tracing::HostTracingProfile tracingProfile) const {
   bool emitted = false;
   sessions_.forEach([&](HostTargetSession& session) {
     if (emitted) {
       /**
-       * TraceRecordingState object is not copiable for performance reasons,
+       * 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.
@@ -396,7 +403,7 @@ void HostTarget::emitTraceRecordingForFirstFuseboxClient(
       return;
     }
     if (session.hasFuseboxClient()) {
-      session.emitTraceRecording(std::move(traceRecording));
+      session.emitHostTracingProfile(std::move(tracingProfile));
       emitted = true;
     }
   });

package/ReactCommon/jsinspector-modern/HostTarget.h

@@ -16,11 +16,16 @@
 #include "ScopedExecutor.h"
 #include "WeakList.h"
 
+#include <functional>
 #include <optional>
+#include <set>
 #include <string>
 
+#include <jsinspector-modern/tracing/FrameTimingSequence.h>
+#include <jsinspector-modern/tracing/HostTracingProfile.h>
+#include <jsinspector-modern/tracing/TraceRecordingState.h>
+#include <jsinspector-modern/tracing/TracingCategory.h>
 #include <jsinspector-modern/tracing/TracingMode.h>
-#include <jsinspector-modern/tracing/TracingState.h>
 
 #ifndef JSINSPECTOR_EXPORT
 #ifdef _MSC_VER
@@ -53,6 +58,36 @@ struct HostTargetMetadata {
   std::optional<std::string> reactNativeVersion{};
 };
 
+/**
+ * Receives any performance-related events from a HostTarget: could be Tracing, Performance Monitor, etc.
+ */
+class HostTargetTracingDelegate {
+ public:
+  HostTargetTracingDelegate() = default;
+  virtual ~HostTargetTracingDelegate() = default;
+
+  /**
+   * Fired when the corresponding HostTarget started recording a tracing session.
+   * The tracing state is expected to be initialized at this point and the delegate should be able to record events
+   * through HostTarget.
+   */
+  virtual void onTracingStarted(tracing::Mode /* tracingMode */, bool /* screenshotsCategoryEnabled */) {}
+
+  /**
+   * Fired when the corresponding HostTarget is about to end recording a tracing session.
+   * The tracing state is expected to be still initialized during the call and the delegate should be able to record
+   * events through HostTarget.
+   *
+   * Any attempts to record events after this callback is finished will fail.
+   */
+  virtual void onTracingStopped() {}
+
+  HostTargetTracingDelegate(const HostTargetTracingDelegate &) = delete;
+  HostTargetTracingDelegate(HostTargetTracingDelegate &&) = delete;
+  HostTargetTracingDelegate &operator=(const HostTargetTracingDelegate &) = delete;
+  HostTargetTracingDelegate &operator=(HostTargetTracingDelegate &&) = delete;
+};
+
 /**
  * Receives events from a HostTarget. This is a shared interface that each
  * React Native platform needs to implement in order to integrate with the
@@ -100,6 +135,19 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
     }
   };
 
+  struct PageCaptureScreenshotRequest {
+    /**
+     * Image compression format. Defaults to "png".
+     * Allowed values: "jpeg", "png", "webp".
+     */
+    std::optional<std::string> format;
+
+    /**
+     * Compression quality from range [0..100] (jpeg only).
+     */
+    std::optional<int> quality;
+  };
+
   virtual ~HostTargetDelegate() override;
 
   /**
@@ -147,18 +195,37 @@ class HostTargetDelegate : public LoadNetworkResourceDelegate {
         "LoadNetworkResourceDelegate.loadNetworkResource is not implemented by this host target delegate.");
   }
 
+  /**
+   * Called when the debugger requests a screenshot of the current page via
+   * @cdp Page.captureScreenshot. The delegate should capture the current
+   * view, encode it to the requested format, and return base64-encoded
+   * image data. Return std::nullopt on failure.
+   */
+  virtual std::optional<std::string> captureScreenshot(const PageCaptureScreenshotRequest & /*request*/)
+  {
+    return std::nullopt;
+  }
+
   /**
    * [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 trace recording state if there is one that needs to be
+   * \return the HostTracingProfile if there is one that needs to be
    * displayed, otherwise std::nullopt.
    */
-  virtual std::optional<tracing::TraceRecordingState> unstable_getTraceRecordingThatWillBeEmittedOnInitialization()
+  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.
+   */
+  virtual HostTargetTracingDelegate *getTracingDelegate()
+  {
+    return nullptr;
+  }
 };
 
 /**
@@ -203,14 +270,16 @@ class HostTargetController final {
    * Starts trace recording for this HostTarget.
    *
    * \param mode In which mode to start the trace recording.
+   * \param enabledCategories The set of categories to enable.
+   *
    * \return false if already tracing, true otherwise.
    */
-  bool startTracing(tracing::Mode mode);
+  bool startTracing(tracing::Mode mode, std::set<tracing::Category> enabledCategories);
 
   /**
    * Stops previously started trace recording.
    */
-  tracing::TraceRecordingState stopTracing();
+  tracing::HostTracingProfile stopTracing();
 
  private:
   HostTarget &target_;
@@ -226,12 +295,15 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
  public:
   /**
    * Constructs a new HostTarget.
+   *
    * \param delegate The HostTargetDelegate that will
    * receive events from this HostTarget. The caller is responsible for ensuring
    * that the HostTargetDelegate outlives this object.
+   *
    * \param executor An executor that may be used to call methods on this
    * HostTarget while it exists. \c create additionally guarantees that the
    * executor will not be called after the HostTarget is destroyed.
+   *
    * \note Copies of the provided executor may be destroyed on arbitrary
    * threads, including after the HostTarget is destroyed. Callers must ensure
    * that such destructor calls are safe - e.g. if using a lambda as the
@@ -279,6 +351,7 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
    */
   void sendCommand(HostCommand command);
 
+#pragma region Tracing
   /**
    * Creates a new HostTracingAgent.
    * This Agent is not owned by the HostTarget. The Agent will be destroyed at
@@ -292,19 +365,16 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
    * Starts trace recording for this HostTarget.
    *
    * \param mode In which mode to start the trace recording.
+   * \param enabledCategories The set of categories to enable.
+   *
    * \return false if already tracing, true otherwise.
    */
-  bool startTracing(tracing::Mode mode);
+  bool startTracing(tracing::Mode mode, std::set<tracing::Category> enabledCategories);
 
   /**
    * Stops previously started trace recording.
    */
-  tracing::TraceRecordingState stopTracing();
-
-  /**
-   * Returns the state of the background trace, running, stopped, or disabled
-   */
-  tracing::TracingState tracingState() const;
+  tracing::HostTracingProfile stopTracing();
 
   /**
    * Returns whether there is an active session with the Fusebox client, i.e.
@@ -313,22 +383,30 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
   bool hasActiveSessionWithFuseboxClient() const;
 
   /**
-   * Emits the trace recording for the first active session with the Fusebox
+   * Emits the HostTracingProfile for the first active session with the Fusebox
    * client.
    *
    * @see \c hasActiveFrontendSession
    */
-  void emitTraceRecordingForFirstFuseboxClient(tracing::TraceRecordingState traceRecording) const;
+  void emitTracingProfileForFirstFuseboxClient(tracing::HostTracingProfile tracingProfile) const;
 
   /**
    * Emits a system state changed event to all active sessions.
    */
   void emitSystemStateChanged(bool isSingleHost) const;
 
+  /**
+   * An endpoint for the Host to report frame timings that will be recorded if and only if there is currently an active
+   * tracing session.
+   */
+  void recordFrameTimings(tracing::FrameTimingSequence frameTimingSequence);
+#pragma endregion
+
  private:
   /**
    * Constructs a new HostTarget.
    * The caller must call setExecutor immediately afterwards.
+   *
    * \param delegate The HostTargetDelegate that will
    * receive events from this HostTarget. The caller is responsible for ensuring
    * that the HostTargetDelegate outlives this object.
@@ -347,6 +425,7 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
   std::unique_ptr<PerfMonitorUpdateHandler> perfMonitorUpdateHandler_;
   std::unique_ptr<HostRuntimeBinding> perfMetricsBinding_;
 
+#pragma region Tracing
   /**
    * Current pending trace recording, which encapsulates the configuration of
    * the tracing session and the state.
@@ -354,6 +433,14 @@ class JSINSPECTOR_EXPORT HostTarget : public EnableExecutorFromThis<HostTarget>
    * Should only be allocated when there is an active tracing session.
    */
   std::unique_ptr<HostTargetTraceRecording> traceRecording_{nullptr};
+  /**
+   * Protects the state inside traceRecording_.
+   *
+   * Calls to tracing subsystem could happen from different threads, depending on the mode (Background or CDP) and
+   * the method: the Host could report frame timings from any arbitrary thread.
+   */
+  std::mutex tracingMutex_;
+#pragma endregion
 
   inline HostTargetDelegate &getDelegate()
   {

package/ReactCommon/jsinspector-modern/HostTargetTraceRecording.cpp

@@ -8,12 +8,26 @@
 #include "HostTargetTraceRecording.h"
 #include "HostTarget.h"
 
+#include <oscompat/OSCompat.h>
+
 namespace facebook::react::jsinspector_modern {
 
 HostTargetTraceRecording::HostTargetTraceRecording(
+    HostTarget& hostTarget,
     tracing::Mode tracingMode,
-    HostTarget& hostTarget)
-    : tracingMode_(tracingMode), hostTarget_(hostTarget) {}
+    std::set<tracing::Category> enabledCategories,
+    std::optional<HighResDuration> windowSize)
+    : hostTarget_(hostTarget),
+      tracingMode_(tracingMode),
+      enabledCategories_(std::move(enabledCategories)),
+      windowSize_(windowSize) {
+  if (windowSize) {
+    frameTimings_ = tracing::TimeWindowedBuffer<tracing::FrameTimingSequence>(
+        [](auto& sequence) { return sequence.beginTimestamp; }, *windowSize);
+  } else {
+    frameTimings_ = tracing::TimeWindowedBuffer<tracing::FrameTimingSequence>();
+  };
+}
 
 void HostTargetTraceRecording::setTracedInstance(
     InstanceTarget* instanceTarget) {
@@ -29,14 +43,13 @@ void HostTargetTraceRecording::start() {
       hostTracingAgent_ == nullptr &&
       "Tracing Agent for the HostTarget was already initialized.");
 
-  state_ = tracing::TraceRecordingState{
-      .mode = tracingMode_,
-      .startTime = HighResTimeStamp::now(),
-  };
+  startTime_ = HighResTimeStamp::now();
+  state_ = tracing::TraceRecordingState(
+      tracingMode_, enabledCategories_, windowSize_);
   hostTracingAgent_ = hostTarget_.createTracingAgent(*state_);
 }
 
-tracing::TraceRecordingState HostTargetTraceRecording::stop() {
+tracing::HostTracingProfile HostTargetTraceRecording::stop() {
   assert(
       hostTracingAgent_ != nullptr &&
       "TracingAgent for the HostTarget has not been initialized.");
@@ -48,7 +61,25 @@ tracing::TraceRecordingState HostTargetTraceRecording::stop() {
   auto state = std::move(*state_);
   state_.reset();
 
-  return state;
+  auto startTime = *startTime_;
+  startTime_.reset();
+
+  return tracing::HostTracingProfile{
+      .processId = oscompat::getCurrentProcessId(),
+      .startTime = startTime,
+      .frameTimings = frameTimings_.pruneExpiredAndExtract(),
+      .instanceTracingProfiles = std::move(state.instanceTracingProfiles),
+      .runtimeSamplingProfiles = std::move(state.runtimeSamplingProfiles),
+  };
+}
+
+void HostTargetTraceRecording::recordFrameTimings(
+    tracing::FrameTimingSequence frameTimingSequence) {
+  assert(
+      state_.has_value() &&
+      "The state for this tracing session has not been initialized.");
+
+  frameTimings_.push(frameTimingSequence);
 }
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostTargetTraceRecording.h

@@ -11,9 +11,15 @@
 #include "HostTarget.h"
 #include "InstanceTarget.h"
 
+#include <jsinspector-modern/tracing/FrameTimingSequence.h>
+#include <jsinspector-modern/tracing/HostTracingProfile.h>
+#include <jsinspector-modern/tracing/TimeWindowedBuffer.h>
 #include <jsinspector-modern/tracing/TraceRecordingState.h>
+#include <jsinspector-modern/tracing/TracingCategory.h>
+#include <react/timing/primitives.h>
 
 #include <optional>
+#include <set>
 
 namespace facebook::react::jsinspector_modern {
 
@@ -28,7 +34,11 @@ namespace facebook::react::jsinspector_modern {
  */
 class HostTargetTraceRecording {
  public:
-  explicit HostTargetTraceRecording(tracing::Mode tracingMode, HostTarget &hostTarget);
+  HostTargetTraceRecording(
+      HostTarget &hostTarget,
+      tracing::Mode tracingMode,
+      std::set<tracing::Category> enabledCategories,
+      std::optional<HighResDuration> windowSize = std::nullopt);
 
   inline bool isBackgroundInitiated() const
   {
@@ -53,22 +63,34 @@ class HostTargetTraceRecording {
   void start();
 
   /**
-   * Stops the recording and drops the recording state.
+   * Stops the recording and returns the recorded HostTracingProfile.
    *
    * Will deallocate all Tracing Agents.
    */
-  tracing::TraceRecordingState stop();
+  tracing::HostTracingProfile stop();
+
+  /**
+   * Adds the frame timing sequence to the current state of this trace recording.
+   *
+   * The caller guarantees the protection from data races. This is protected by the tracing mutex in HostTarget.
+   */
+  void recordFrameTimings(tracing::FrameTimingSequence frameTimingSequence);
 
  private:
+  /**
+   * The Host for which this Trace Recording is going to happen.
+   */
+  HostTarget &hostTarget_;
+
   /**
    * The mode in which this trace recording was initialized.
    */
   tracing::Mode tracingMode_;
 
   /**
-   * The Host for which this Trace Recording is going to happen.
+   * The timestamp at which this Trace Recording started.
    */
-  HostTarget &hostTarget_;
+  std::optional<HighResTimeStamp> startTime_;
 
   /**
    * The state of the current Trace Recording.
@@ -81,6 +103,21 @@ class HostTargetTraceRecording {
    * Only allocated if the recording is enabled.
    */
   std::shared_ptr<HostTracingAgent> hostTracingAgent_;
+
+  /**
+   * The list of categories that are enabled for this recording.
+   */
+  std::set<tracing::Category> enabledCategories_;
+
+  /**
+   * The size of the time window for this recording.
+   */
+  std::optional<HighResDuration> windowSize_;
+
+  /**
+   * Frame timings captured on the Host side.
+   */
+  tracing::TimeWindowedBuffer<tracing::FrameTimingSequence> frameTimings_;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/HostTargetTracing.cpp

@@ -5,18 +5,27 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include <jsinspector-modern/tracing/TracingState.h>
-
 #include "HostTarget.h"
 #include "HostTargetTraceRecording.h"
 
 namespace facebook::react::jsinspector_modern {
 
-bool HostTargetController::startTracing(tracing::Mode tracingMode) {
-  return target_.startTracing(tracingMode);
+namespace {
+
+// The size of the timeline for the trace recording that happened in the
+// background.
+constexpr HighResDuration kBackgroundTraceWindowSize =
+    HighResDuration::fromMilliseconds(20000);
+
+} // namespace
+
+bool HostTargetController::startTracing(
+    tracing::Mode tracingMode,
+    std::set<tracing::Category> enabledCategories) {
+  return target_.startTracing(tracingMode, std::move(enabledCategories));
 }
 
-tracing::TraceRecordingState HostTargetController::stopTracing() {
+tracing::HostTracingProfile HostTargetController::stopTracing() {
   return target_.stopTracing();
 }
 
@@ -27,45 +36,69 @@ std::shared_ptr<HostTracingAgent> HostTarget::createTracingAgent(
   return agent;
 }
 
-bool HostTarget::startTracing(tracing::Mode tracingMode) {
+bool HostTarget::startTracing(
+    tracing::Mode tracingMode,
+    std::set<tracing::Category> enabledCategories) {
+  std::lock_guard lock(tracingMutex_);
+
   if (traceRecording_ != nullptr) {
     if (traceRecording_->isBackgroundInitiated() &&
         tracingMode == tracing::Mode::CDP) {
+      if (auto tracingDelegate = delegate_.getTracingDelegate()) {
+        tracingDelegate->onTracingStopped();
+      }
+
+      traceRecording_->stop();
       traceRecording_.reset();
     } else {
       return false;
     }
   }
 
-  traceRecording_ =
-      std::make_unique<HostTargetTraceRecording>(tracingMode, *this);
+  auto timeWindow = tracingMode == tracing::Mode::Background
+      ? std::make_optional(kBackgroundTraceWindowSize)
+      : std::nullopt;
+  auto screenshotsCategoryEnabled =
+      enabledCategories.contains(tracing::Category::Screenshot);
+
+  traceRecording_ = std::make_unique<HostTargetTraceRecording>(
+      *this, tracingMode, std::move(enabledCategories), timeWindow);
   traceRecording_->setTracedInstance(currentInstance_.get());
   traceRecording_->start();
 
+  if (auto tracingDelegate = delegate_.getTracingDelegate()) {
+    tracingDelegate->onTracingStarted(tracingMode, screenshotsCategoryEnabled);
+  }
+
   return true;
 }
 
-tracing::TraceRecordingState HostTarget::stopTracing() {
+tracing::HostTracingProfile HostTarget::stopTracing() {
+  std::lock_guard lock(tracingMutex_);
+
   assert(traceRecording_ != nullptr && "No tracing in progress");
 
-  auto state = traceRecording_->stop();
+  if (auto tracingDelegate = delegate_.getTracingDelegate()) {
+    tracingDelegate->onTracingStopped();
+  }
+
+  auto profile = traceRecording_->stop();
   traceRecording_.reset();
 
-  return state;
+  return profile;
 }
 
-tracing::TracingState HostTarget::tracingState() const {
-  if (traceRecording_ == nullptr) {
-    return tracing::TracingState::Disabled;
-  }
+void HostTarget::recordFrameTimings(
+    tracing::FrameTimingSequence frameTimingSequence) {
+  std::lock_guard lock(tracingMutex_);
 
-  if (traceRecording_->isBackgroundInitiated()) {
-    return tracing::TracingState::EnabledInBackgroundMode;
+  if (traceRecording_) {
+    traceRecording_->recordFrameTimings(std::move(frameTimingSequence));
+  } else {
+    assert(
+        false &&
+        "The HostTarget is not being profiled. Did you call recordFrameTimings() from the native Host side when there is no tracing in progress?");
   }
-
-  // This means we have a traceRecording_, but not running in the background.
-  // CDP initiated this trace so we should report as disabled.
-  return tracing::TracingState::EnabledInCDPMode;
 }
 
 } // namespace facebook::react::jsinspector_modern

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>
+{
+  /**
+   * Maximum serialized byte size of a Trace Event chunk before it is flushed
+   * with a Tracing.dataCollected event.
+   */
+  static constexpr size_t TRACE_EVENT_CHUNK_MAX_BYTES = 10 * 1024 * 1024; // 10 MiB
+
+  /**
+   * 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_MAX_BYTES,
+      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