react-native 0.83.3 → 0.83.5

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.cpp

@@ -16,6 +16,36 @@ using namespace facebook::jni;
 using namespace facebook::react::jsinspector_modern;
 
 namespace facebook::react {
+
+namespace {
+jni::local_ref<JTracingState::javaobject> convertCPPTracingStateToJava(
+    TracingState tracingState) {
+  auto tracingStateClass = jni::findClassLocal(
+      "com/facebook/react/devsupport/inspector/TracingState");
+  auto valueOfMethod =
+      tracingStateClass->getStaticMethod<JTracingState(jstring)>("valueOf");
+
+  switch (tracingState) {
+    case TracingState::Disabled:
+      return valueOfMethod(
+          tracingStateClass, jni::make_jstring("DISABLED").get());
+
+    case TracingState::EnabledInBackgroundMode:
+      return valueOfMethod(
+          tracingStateClass,
+          jni::make_jstring("ENABLED_IN_BACKGROUND_MODE").get());
+
+    case TracingState::EnabledInCDPMode:
+      return valueOfMethod(
+          tracingStateClass, jni::make_jstring("ENABLED_IN_CDP_MODE").get());
+
+    default:
+      jni::throwNewJavaException(
+          "java/lang/IllegalStateException", "Unexpected new TracingState.");
+  }
+}
+} // namespace
+
 JReactHostInspectorTarget::JReactHostInspectorTarget(
     alias_ref<JReactHostInspectorTarget::javaobject> jobj,
     alias_ref<JReactHostImpl> reactHostImpl,
@@ -29,7 +59,8 @@ JReactHostInspectorTarget::JReactHostInspectorTarget(
                              std::function<void()>&& callback) mutable {
         auto jrunnable = JNativeRunnable::newObjectCxxArgs(std::move(callback));
         javaExecutor->execute(jrunnable);
-      }) {
+      }),
+      tracingDelegate_(std::make_unique<TracingDelegate>()) {
   auto& inspectorFlags = InspectorFlags::getInstance();
   if (inspectorFlags.getFuseboxEnabled()) {
     inspectorTarget_ = HostTarget::create(*this, inspectorExecutor_);
@@ -140,13 +171,34 @@ void JReactHostInspectorTarget::loadNetworkResource(
   }
 }
 
+std::optional<std::string> JReactHostInspectorTarget::captureScreenshot(
+    const jsinspector_modern::HostTargetDelegate::PageCaptureScreenshotRequest&
+        request) {
+  if (auto javaReactHostImplStrong = javaReactHostImpl_->get()) {
+    std::string format = request.format.value_or("png");
+    int quality = request.quality.value_or(-1);
+    auto result = javaReactHostImplStrong->captureScreenshot(format, quality);
+    if (result) {
+      return result->toStdString();
+    }
+  }
+  return std::nullopt;
+}
+
 HostTarget* JReactHostInspectorTarget::getInspectorTarget() {
   return inspectorTarget_ ? inspectorTarget_.get() : nullptr;
 }
 
 bool JReactHostInspectorTarget::startBackgroundTrace() {
   if (inspectorTarget_) {
-    return inspectorTarget_->startTracing(tracing::Mode::Background);
+    return inspectorTarget_->startTracing(
+        tracing::Mode::Background,
+        {
+            tracing::Category::HiddenTimeline,
+            tracing::Category::RuntimeExecution,
+            tracing::Category::Timeline,
+            tracing::Category::UserTiming,
+        });
   } else {
     jni::throwNewJavaException(
         "java/lang/IllegalStateException",
@@ -154,7 +206,7 @@ bool JReactHostInspectorTarget::startBackgroundTrace() {
   }
 }
 
-tracing::TraceRecordingState JReactHostInspectorTarget::stopTracing() {
+tracing::HostTracingProfile JReactHostInspectorTarget::stopTracing() {
   if (inspectorTarget_) {
     return inspectorTarget_->stopTracing();
   } else {
@@ -167,12 +219,12 @@ tracing::TraceRecordingState JReactHostInspectorTarget::stopTracing() {
 jboolean JReactHostInspectorTarget::stopAndMaybeEmitBackgroundTrace() {
   auto capturedTrace = inspectorTarget_->stopTracing();
   if (inspectorTarget_->hasActiveSessionWithFuseboxClient()) {
-    inspectorTarget_->emitTraceRecordingForFirstFuseboxClient(
+    inspectorTarget_->emitTracingProfileForFirstFuseboxClient(
         std::move(capturedTrace));
     return jboolean(true);
   }
 
-  stashTraceRecordingState(std::move(capturedTrace));
+  stashTracingProfile(std::move(capturedTrace));
   return jboolean(false);
 }
 
@@ -180,16 +232,16 @@ void JReactHostInspectorTarget::stopAndDiscardBackgroundTrace() {
   inspectorTarget_->stopTracing();
 }
 
-void JReactHostInspectorTarget::stashTraceRecordingState(
-    tracing::TraceRecordingState&& state) {
-  stashedTraceRecordingState_ = std::move(state);
+void JReactHostInspectorTarget::stashTracingProfile(
+    tracing::HostTracingProfile&& hostTracingProfile) {
+  stashedTracingProfile_ = std::move(hostTracingProfile);
 }
 
-std::optional<tracing::TraceRecordingState> JReactHostInspectorTarget::
-    unstable_getTraceRecordingThatWillBeEmittedOnInitialization() {
-  auto state = std::move(stashedTraceRecordingState_);
-  stashedTraceRecordingState_.reset();
-  return state;
+std::optional<tracing::HostTracingProfile> JReactHostInspectorTarget::
+    unstable_getHostTracingProfileThatWillBeEmittedOnInitialization() {
+  auto tracingProfile = std::move(stashedTracingProfile_);
+  stashedTracingProfile_.reset();
+  return tracingProfile;
 }
 
 void JReactHostInspectorTarget::registerNatives() {
@@ -208,13 +260,140 @@ void JReactHostInspectorTarget::registerNatives() {
           "stopAndDiscardBackgroundTrace",
           JReactHostInspectorTarget::stopAndDiscardBackgroundTrace),
       makeNativeMethod(
-          "tracingStateAsInt", JReactHostInspectorTarget::tracingState),
+          "getTracingState", JReactHostInspectorTarget::getTracingState),
+      makeNativeMethod(
+          "registerTracingStateListener",
+          JReactHostInspectorTarget::registerTracingStateListener),
+      makeNativeMethod(
+          "unregisterTracingStateListener",
+          JReactHostInspectorTarget::unregisterTracingStateListener),
+      makeNativeMethod(
+          "recordFrameTimings", JReactHostInspectorTarget::recordFrameTimings),
+  });
+}
+
+jni::local_ref<JTracingState::javaobject>
+JReactHostInspectorTarget::getTracingState() {
+  return convertCPPTracingStateToJava(tracingDelegate_->getTracingState());
+}
+
+jlong JReactHostInspectorTarget::registerTracingStateListener(
+    jni::alias_ref<JTracingStateListener::javaobject> listener) {
+  auto cppListener = [globalRef = make_global(listener)](
+                         TracingState state, bool screenshotsEnabled) {
+    static auto method =
+        globalRef->getClass()
+            ->getMethod<void(
+                jni::local_ref<JTracingState::javaobject>, jboolean)>(
+                "onStateChanged");
+
+    method(
+        globalRef,
+        convertCPPTracingStateToJava(state),
+        static_cast<jboolean>(screenshotsEnabled));
+  };
+
+  return static_cast<jlong>(
+      tracingDelegate_->registerTracingStateListener(std::move(cppListener)));
+}
+
+void JReactHostInspectorTarget::unregisterTracingStateListener(
+    jlong subscriptionId) {
+  tracingDelegate_->unregisterTracingStateListener(subscriptionId);
+}
+
+HostTargetTracingDelegate* JReactHostInspectorTarget::getTracingDelegate() {
+  return tracingDelegate_.get();
+}
+
+void JReactHostInspectorTarget::recordFrameTimings(
+    jni::alias_ref<JFrameTimingSequence::javaobject> frameTimingSequence) {
+  inspectorTarget_->recordFrameTimings({
+      frameTimingSequence->getId(),
+      frameTimingSequence->getThreadId(),
+      frameTimingSequence->getBeginTimestamp(),
+      frameTimingSequence->getEndTimestamp(),
+      frameTimingSequence->getScreenshot(),
   });
 }
 
-jint JReactHostInspectorTarget::tracingState() {
-  auto state = inspectorTarget_->tracingState();
-  return static_cast<jint>(state);
+void TracingDelegate::onTracingStarted(
+    tracing::Mode tracingMode,
+    bool screenshotsCategoryEnabled) {
+  TracingState nextState = TracingState::Disabled;
+  switch (tracingMode) {
+    case tracing::Mode::CDP:
+      nextState = TracingState::EnabledInCDPMode;
+      break;
+    case tracing::Mode::Background:
+      nextState = TracingState::EnabledInBackgroundMode;
+      break;
+    default:
+      throw std::logic_error("Unexpected new Tracing Mode");
+  }
+
+  std::vector<TracingStateListener> listeners;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    tracingState_ = nextState;
+    listeners = copySubscribedListeners();
+  }
+
+  notifyListeners(listeners, nextState, screenshotsCategoryEnabled);
+}
+
+void TracingDelegate::onTracingStopped() {
+  std::vector<TracingStateListener> listeners;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    tracingState_ = TracingState::Disabled;
+    listeners = copySubscribedListeners();
+  }
+
+  notifyListeners(listeners, TracingState::Disabled, false);
+}
+
+TracingState TracingDelegate::getTracingState() {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  return tracingState_;
+}
+
+size_t TracingDelegate::registerTracingStateListener(
+    TracingStateListener listener) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  auto id = nextSubscriptionId_++;
+  subscriptions_[id] = std::move(listener);
+  return id;
+}
+
+void TracingDelegate::unregisterTracingStateListener(size_t subscriptionId) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  subscriptions_.erase(subscriptionId);
+}
+
+std::vector<TracingStateListener> TracingDelegate::copySubscribedListeners() {
+  std::vector<TracingStateListener> listeners;
+  listeners.reserve(subscriptions_.size());
+
+  for (auto& [_, listener] : subscriptions_) {
+    listeners.push_back(listener);
+  }
+
+  return listeners;
+}
+
+void TracingDelegate::notifyListeners(
+    const std::vector<TracingStateListener>& listeners,
+    TracingState state,
+    bool screenshotsCategoryEnabled) {
+  for (const auto& listener : listeners) {
+    listener(state, screenshotsCategoryEnabled);
+  }
 }
 
 } // namespace facebook::react

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.h

@@ -7,11 +7,17 @@
 
 #pragma once
 
+#include <fbjni/ByteBuffer.h>
 #include <fbjni/fbjni.h>
+
 #include <jsinspector-modern/HostTarget.h>
 #include <react/jni/InspectorNetworkRequestListener.h>
 #include <react/jni/JExecutor.h>
+
+#include <mutex>
+#include <optional>
 #include <string>
+#include <vector>
 
 namespace facebook::react {
 
@@ -20,7 +26,56 @@ struct JTaskInterface : public jni::JavaClass<JTaskInterface> {
 };
 
 struct JTracingState : public jni::JavaClass<JTracingState> {
-  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/TracingState;";
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/inspector/TracingState;";
+};
+
+struct JTracingStateListener : public jni::JavaClass<JTracingStateListener> {
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/inspector/TracingStateListener;";
+};
+
+struct JFrameTimingSequence : public jni::JavaClass<JFrameTimingSequence> {
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/devsupport/inspector/FrameTimingSequence;";
+
+  uint64_t getId() const
+  {
+    auto field = javaClassStatic()->getField<jint>("id");
+    return static_cast<uint64_t>(getFieldValue(field));
+  }
+
+  uint64_t getThreadId() const
+  {
+    auto field = javaClassStatic()->getField<jint>("threadId");
+    return static_cast<uint64_t>(getFieldValue(field));
+  }
+
+  HighResTimeStamp getBeginTimestamp() const
+  {
+    auto field = javaClassStatic()->getField<jlong>("beginTimestamp");
+    return HighResTimeStamp::fromChronoSteadyClockTimePoint(
+        std::chrono::steady_clock::time_point(std::chrono::nanoseconds(getFieldValue(field))));
+  }
+
+  HighResTimeStamp getEndTimestamp() const
+  {
+    auto field = javaClassStatic()->getField<jlong>("endTimestamp");
+    return HighResTimeStamp::fromChronoSteadyClockTimePoint(
+        std::chrono::steady_clock::time_point(std::chrono::nanoseconds(getFieldValue(field))));
+  }
+
+  std::optional<std::vector<uint8_t>> getScreenshot() const
+  {
+    auto field = javaClassStatic()->getField<jbyteArray>("screenshot");
+    auto javaScreenshot = getFieldValue(field);
+    if (javaScreenshot) {
+      auto size = static_cast<size_t>(javaScreenshot->size());
+      if (size > 0) {
+        std::vector<uint8_t> result(size);
+        javaScreenshot->getRegion(0, javaScreenshot->size(), reinterpret_cast<jbyte *>(result.data()));
+        return result;
+      }
+    }
+    return std::nullopt;
+  }
 };
 
 struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {
@@ -53,6 +108,78 @@ struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {
                           "loadNetworkResource");
     return method(self(), jni::make_jstring(url), listener);
   }
+
+  jni::local_ref<jni::JString> captureScreenshot(const std::string &format, int quality) const
+  {
+    auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::local_ref<jni::JString>, jint)>(
+        "captureScreenshot");
+    return method(self(), jni::make_jstring(format), static_cast<jint>(quality));
+  }
+};
+
+enum class TracingState {
+  Disabled,
+  EnabledInBackgroundMode,
+  EnabledInCDPMode,
+};
+
+/**
+ * A callback that will be invoked when tracing state has changed.
+ */
+using TracingStateListener = std::function<void(TracingState state, bool screenshotsCategoryEnabled)>;
+
+class TracingDelegate : public jsinspector_modern::HostTargetTracingDelegate {
+ public:
+  void onTracingStarted(jsinspector_modern::tracing::Mode tracingMode, bool screenshotsCategoryEnabled) override;
+  void onTracingStopped() override;
+
+  /**
+   * A synchronous way to get the current tracing state.
+   * Could be called from any thread.
+   */
+  TracingState getTracingState();
+  /**
+   * Register a listener that will be notified when the tracing state changes.
+   * Could be called from any thread.
+   */
+  size_t registerTracingStateListener(TracingStateListener listener);
+  /**
+   * Unregister previously registered listener with the id returned from
+   * TracingDelegate::registerTracingStateListener().
+   */
+  void unregisterTracingStateListener(size_t subscriptionId);
+
+ private:
+  /**
+   * Covers read / write operations on tracingState_ and subscriptions_.
+   */
+  std::mutex mutex_;
+  /**
+   * Since HostInspectorTarget creates HostTarget, the default value is Disabled.
+   * However, the TracingDelegate is subscribed at the construction of HostTarget, so it will be notified as early as
+   * possible.
+   */
+  TracingState tracingState_ = TracingState::Disabled;
+  /**
+   * Map of subscription ID to listener.
+   */
+  std::unordered_map<size_t, TracingStateListener> subscriptions_;
+  /**
+   * A counter for generating unique subscription IDs.
+   */
+  uint64_t nextSubscriptionId_ = 0;
+  /**
+   * Returns a collection of listeners that are subscribed at the time of the call.
+   * Expected to be only called with mutex_ locked.
+   */
+  std::vector<TracingStateListener> copySubscribedListeners();
+  /**
+   * Notifies specified listeners about the state change.
+   */
+  void notifyListeners(
+      const std::vector<TracingStateListener> &listeners,
+      TracingState state,
+      bool screenshotsCategoryEnabled);
 };
 
 class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTarget>,
@@ -70,14 +197,6 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
   static void registerNatives();
   void sendDebuggerResumeCommand();
 
-  /**
-   * Get the state of the background trace: running, stopped, or disabled
-   * Background tracing will be disabled if there is no metro connection or if
-   * there is a CDP initiate trace in progress.
-   *
-   * \return the background trace state
-   */
-  jint tracingState();
   /**
    * Starts a background trace recording for this HostTarget.
    *
@@ -99,6 +218,31 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
 
   jsinspector_modern::HostTarget *getInspectorTarget();
 
+  /**
+   * Get the current tracing state. Could be called from any thread.
+   */
+  jni::local_ref<JTracingState::javaobject> getTracingState();
+
+  /**
+   * Register a listener that will be notified when the tracing state changes.
+   * Could be called from any thread.
+   *
+   * \return A unique subscription ID to use for unregistering the listener.
+   */
+  jlong registerTracingStateListener(jni::alias_ref<JTracingStateListener::javaobject> listener);
+
+  /**
+   * Unregister a previously registered tracing state listener.
+   *
+   * \param subscriptionId The subscription ID returned from JReactHostInspectorTarget::registerTracingStateListener.
+   */
+  void unregisterTracingStateListener(jlong subscriptionId);
+
+  /**
+   * Propagate frame timings information to the Inspector's Tracing subsystem.
+   */
+  void recordFrameTimings(jni::alias_ref<JFrameTimingSequence::javaobject> frameTimingSequence);
+
   // HostTargetDelegate methods
   jsinspector_modern::HostTargetMetadata getMetadata() override;
   void onReload(const PageReloadRequest &request) override;
@@ -107,8 +251,11 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
   void loadNetworkResource(
       const jsinspector_modern::LoadNetworkResourceRequest &params,
       jsinspector_modern::ScopedExecutor<jsinspector_modern::NetworkRequestListener> executor) override;
-  std::optional<jsinspector_modern::tracing::TraceRecordingState>
-  unstable_getTraceRecordingThatWillBeEmittedOnInitialization() override;
+  std::optional<std::string> captureScreenshot(
+      const jsinspector_modern::HostTargetDelegate::PageCaptureScreenshotRequest &request) override;
+  std::optional<jsinspector_modern::tracing::HostTracingProfile>
+  unstable_getHostTracingProfileThatWillBeEmittedOnInitialization() override;
+  jsinspector_modern::HostTargetTracingDelegate *getTracingDelegate() override;
 
  private:
   JReactHostInspectorTarget(
@@ -126,20 +273,23 @@ class JReactHostInspectorTarget : public jni::HybridClass<JReactHostInspectorTar
   std::optional<int> inspectorPageId_;
 
   /**
-   * Stops previously started trace recording and returns the captured trace.
+   * Stops previously started trace recording and returns the captured HostTracingProfile.
    */
-  jsinspector_modern::tracing::TraceRecordingState stopTracing();
+  jsinspector_modern::tracing::HostTracingProfile stopTracing();
   /**
-   * Stashes previously recorded trace recording state that will be emitted when
+   * Stashes previously recorded HostTracingProfile that will be emitted when
    * CDP session is created. Once emitted, the value will be cleared from this
    * instance.
    */
-  void stashTraceRecordingState(jsinspector_modern::tracing::TraceRecordingState &&state);
+  void stashTracingProfile(jsinspector_modern::tracing::HostTracingProfile &&hostTracingProfile);
+  /**
+   * Previously recorded HostTracingProfile that will be emitted when CDP session is created.
+   */
+  std::optional<jsinspector_modern::tracing::HostTracingProfile> stashedTracingProfile_;
   /**
-   * Previously recorded trace recording state that will be emitted when
-   * CDP session is created.
+   * Encapsulates the logic around tracing for this HostInspectorTarget.
    */
-  std::optional<jsinspector_modern::tracing::TraceRecordingState> stashedTraceRecordingState_;
+  std::unique_ptr<TracingDelegate> tracingDelegate_;
 
   friend HybridBase;
 };

package/ReactAndroid/src/main/jni/third-party/folly/CMakeLists.txt

@@ -43,6 +43,7 @@ SET(folly_runtime_SRC
         folly/json/json_pointer.cpp
         folly/json/json.cpp
         folly/lang/CString.cpp
+        folly/lang/Exception.cpp
         folly/lang/SafeAssert.cpp
         folly/lang/ToAscii.cpp
         folly/memory/detail/MallocImpl.cpp

package/ReactCommon/cxxreact/ReactNativeVersion.h

@@ -14,14 +14,14 @@
 
 #define REACT_NATIVE_VERSION_MAJOR 0
 #define REACT_NATIVE_VERSION_MINOR 83
-#define REACT_NATIVE_VERSION_PATCH 3
+#define REACT_NATIVE_VERSION_PATCH 5
 
 namespace facebook::react {
 
 constexpr struct {
   int32_t Major = 0;
   int32_t Minor = 83;
-  int32_t Patch = 3;
+  int32_t Patch = 5;
   std::string_view Prerelease = "";
 } ReactNativeVersion;
 

package/ReactCommon/jsinspector-modern/HostAgent.cpp

@@ -198,6 +198,42 @@ class HostAgent::Impl final {
           .shouldSendOKResponse = true,
       };
     }
+    if (InspectorFlags::getInstance().getScreenshotCaptureEnabled()) {
+      if (req.method == "Page.captureScreenshot") {
+        std::optional<std::string> format;
+        std::optional<int> quality;
+
+        if (req.params.isObject()) {
+          if (req.params.count("format") != 0u) {
+            format = req.params.at("format").asString();
+          }
+          if (req.params.count("quality") != 0u) {
+            quality = static_cast<int>(req.params.at("quality").asInt());
+          }
+        }
+
+        auto base64Data = targetController_.getDelegate().captureScreenshot(
+            {.format = format, .quality = quality});
+
+        if (base64Data.has_value()) {
+          frontendChannel_(
+              cdp::jsonResult(
+                  req.id,
+                  folly::dynamic::object("data", std::move(*base64Data))));
+        } else {
+          frontendChannel_(
+              cdp::jsonError(
+                  req.id,
+                  cdp::ErrorCode::InternalError,
+                  "Failed to capture screenshot"));
+        }
+
+        return {
+            .isFinishedHandlingRequest = true,
+            .shouldSendOKResponse = false,
+        };
+      }
+    }
     if (req.method == "Overlay.setPausedInDebuggerMessage") {
       auto message =
           req.params.isObject() && (req.params.count("message") != 0u)
@@ -238,9 +274,9 @@ class HostAgent::Impl final {
 
       auto stashedTraceRecording =
           targetController_.getDelegate()
-              .unstable_getTraceRecordingThatWillBeEmittedOnInitialization();
+              .unstable_getHostTracingProfileThatWillBeEmittedOnInitialization();
       if (stashedTraceRecording.has_value()) {
-        tracingAgent_.emitExternalTraceRecording(
+        tracingAgent_.emitExternalHostTracingProfile(
             std::move(stashedTraceRecording.value()));
       }
 
@@ -385,12 +421,12 @@ class HostAgent::Impl final {
     return fuseboxClientType_ == FuseboxClientType::Fusebox;
   }
 
-  void emitExternalTraceRecording(
-      tracing::TraceRecordingState traceRecording) const {
+  void emitExternalTracingProfile(
+      tracing::HostTracingProfile tracingProfile) const {
     assert(
         hasFuseboxClientConnected() &&
         "Attempted to emit a trace recording to a non-Fusebox client");
-    tracingAgent_.emitExternalTraceRecording(std::move(traceRecording));
+    tracingAgent_.emitExternalHostTracingProfile(std::move(tracingProfile));
   }
 
   void emitSystemStateChanged(bool isSingleHost) {
@@ -506,8 +542,7 @@ class HostAgent::Impl final {
   bool hasFuseboxClientConnected() const {
     return false;
   }
-  void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) {
-  }
+  void emitExternalTracingProfile(tracing::HostTracingProfile tracingProfile) {}
   void emitSystemStateChanged(bool isSingleHost) {}
 };
 
@@ -543,9 +578,9 @@ bool HostAgent::hasFuseboxClientConnected() const {
   return impl_->hasFuseboxClientConnected();
 }
 
-void HostAgent::emitExternalTraceRecording(
-    tracing::TraceRecordingState traceRecording) const {
-  impl_->emitExternalTraceRecording(std::move(traceRecording));
+void HostAgent::emitExternalTracingProfile(
+    tracing::HostTracingProfile tracingProfile) const {
+  impl_->emitExternalTracingProfile(std::move(tracingProfile));
 }
 
 void HostAgent::emitSystemStateChanged(bool isSingleHost) const {

package/ReactCommon/jsinspector-modern/HostAgent.h

@@ -74,10 +74,10 @@ class HostAgent final {
   bool hasFuseboxClientConnected() const;
 
   /**
-   * Emits the trace recording that was captured externally, not via the
+   * Emits the HostTracingProfile that was captured externally, not via the
    * CDP-initiated request.
    */
-  void emitExternalTraceRecording(tracing::TraceRecordingState traceRecording) const;
+  void emitExternalTracingProfile(tracing::HostTracingProfile tracingProfile) const;
 
   /**
    * Emits a system state changed event when the number of ReactHost instances