react-native-tvos 0.81.3-0 → 0.82.0-0

package/ReactCommon/jsinspector-modern/InspectorPackagerConnection.cpp

@@ -14,6 +14,7 @@
 #include <glog/logging.h>
 #include <cerrno>
 #include <chrono>
+#include <utility>
 
 using namespace std::literals;
 
@@ -34,7 +35,10 @@ InspectorPackagerConnection::Impl::create(
   // No make_shared because the constructor is private
   std::shared_ptr<InspectorPackagerConnection::Impl> impl(
       new InspectorPackagerConnection::Impl(
-          url, deviceName, appName, std::move(delegate)));
+          std::move(url),
+          std::move(deviceName),
+          std::move(appName),
+          std::move(delegate)));
   getInspectorInstance().registerPageStatusListener(impl);
   return impl;
 }
@@ -50,7 +54,7 @@ InspectorPackagerConnection::Impl::Impl(
       delegate_(std::move(delegate)) {}
 
 void InspectorPackagerConnection::Impl::handleProxyMessage(
-    folly::const_dynamic_view message) {
+    const folly::const_dynamic_view& message) {
   std::string event = message.descend("event").string_or(INVALID);
   if (event == "getPages") {
     sendToPackager(
@@ -67,7 +71,7 @@ void InspectorPackagerConnection::Impl::handleProxyMessage(
 }
 
 void InspectorPackagerConnection::Impl::sendEventToAllConnections(
-    std::string event) {
+    const std::string& event) {
   for (auto& connection : inspectorSessions_) {
     connection.second.localConnection->sendMessage(event);
   }
@@ -81,7 +85,7 @@ void InspectorPackagerConnection::Impl::closeAllConnections() {
 }
 
 void InspectorPackagerConnection::Impl::handleConnect(
-    folly::const_dynamic_view payload) {
+    const folly::const_dynamic_view& payload) {
   std::string pageId = payload.descend("pageId").string_or(INVALID);
   auto existingConnectionIt = inspectorSessions_.find(pageId);
   if (existingConnectionIt != inspectorSessions_.end()) {
@@ -91,7 +95,7 @@ void InspectorPackagerConnection::Impl::handleConnect(
     LOG(WARNING) << "Already connected: " << pageId;
     return;
   }
-  int pageIdInt;
+  int pageIdInt = 0;
   try {
     pageIdInt = std::stoi(pageId);
   } catch (...) {
@@ -123,7 +127,7 @@ void InspectorPackagerConnection::Impl::handleConnect(
 }
 
 void InspectorPackagerConnection::Impl::handleDisconnect(
-    folly::const_dynamic_view payload) {
+    const folly::const_dynamic_view& payload) {
   std::string pageId = payload.descend("pageId").string_or(INVALID);
   auto inspectorConnection = removeConnectionForPage(pageId);
   if (inspectorConnection) {
@@ -132,7 +136,8 @@ void InspectorPackagerConnection::Impl::handleDisconnect(
 }
 
 std::unique_ptr<ILocalConnection>
-InspectorPackagerConnection::Impl::removeConnectionForPage(std::string pageId) {
+InspectorPackagerConnection::Impl::removeConnectionForPage(
+    const std::string& pageId) {
   auto it = inspectorSessions_.find(pageId);
   if (it != inspectorSessions_.end()) {
     auto connection = std::move(it->second);
@@ -143,7 +148,7 @@ InspectorPackagerConnection::Impl::removeConnectionForPage(std::string pageId) {
 }
 
 void InspectorPackagerConnection::Impl::handleWrappedEvent(
-    folly::const_dynamic_view payload) {
+    const folly::const_dynamic_view& payload) {
   std::string pageId = payload.descend("pageId").string_or(INVALID);
   std::string wrappedEvent = payload.descend("wrappedEvent").string_or(INVALID);
   auto connectionIt = inspectorSessions_.find(pageId);
@@ -195,7 +200,7 @@ void InspectorPackagerConnection::Impl::didReceiveMessage(
                << e.what();
     return;
   }
-  handleProxyMessage(std::move(parsedJSON));
+  handleProxyMessage(parsedJSON);
 }
 
 void InspectorPackagerConnection::Impl::didOpen() {
@@ -263,10 +268,6 @@ void InspectorPackagerConnection::Impl::reconnect() {
           }
 
           strongSelf->connect();
-
-          if (!strongSelf->isConnected()) {
-            strongSelf->reconnect();
-          }
         }
       },
       RECONNECT_DELAY);
@@ -277,7 +278,8 @@ void InspectorPackagerConnection::Impl::closeQuietly() {
   disposeWebSocket();
 }
 
-void InspectorPackagerConnection::Impl::sendToPackager(folly::dynamic message) {
+void InspectorPackagerConnection::Impl::sendToPackager(
+    const folly::dynamic& message) {
   if (!webSocket_) {
     return;
   }
@@ -288,7 +290,7 @@ void InspectorPackagerConnection::Impl::sendToPackager(folly::dynamic message) {
 void InspectorPackagerConnection::Impl::scheduleSendToPackager(
     folly::dynamic message,
     SessionId sourceSessionId,
-    std::string sourcePageId) {
+    const std::string& sourcePageId) {
   delegate_->scheduleCallback(
       [weakSelf = weak_from_this(),
        message = std::move(message),
@@ -331,7 +333,7 @@ InspectorPackagerConnection::Impl::RemoteConnection::RemoteConnection(
     std::weak_ptr<InspectorPackagerConnection::Impl> owningPackagerConnection,
     std::string pageId,
     SessionId sessionId)
-    : owningPackagerConnection_(owningPackagerConnection),
+    : owningPackagerConnection_(std::move(owningPackagerConnection)),
       pageId_(std::move(pageId)),
       sessionId_(sessionId) {}
 
@@ -367,7 +369,11 @@ InspectorPackagerConnection::InspectorPackagerConnection(
     std::string deviceName,
     std::string appName,
     std::unique_ptr<InspectorPackagerConnectionDelegate> delegate)
-    : impl_(Impl::create(url, deviceName, appName, std::move(delegate))) {}
+    : impl_(Impl::create(
+          std::move(url),
+          std::move(deviceName),
+          std::move(appName),
+          std::move(delegate))) {}
 
 bool InspectorPackagerConnection::isConnected() const {
   return impl_->isConnected();

package/ReactCommon/jsinspector-modern/InspectorPackagerConnectionImpl.h

@@ -39,8 +39,9 @@ class InspectorPackagerConnection::Impl
   bool isConnected() const;
   void connect();
   void closeQuietly();
-  void sendEventToAllConnections(std::string event);
-  std::unique_ptr<ILocalConnection> removeConnectionForPage(std::string pageId);
+  void sendEventToAllConnections(const std::string& event);
+  std::unique_ptr<ILocalConnection> removeConnectionForPage(
+      const std::string& pageId);
 
   /**
    * Send a message to the packager as soon as possible. This method is safe
@@ -51,7 +52,7 @@ class InspectorPackagerConnection::Impl
   void scheduleSendToPackager(
       folly::dynamic message,
       SessionId sourceSessionId,
-      std::string sourcePageId);
+      const std::string& sourcePageId);
 
  private:
   struct Session {
@@ -68,15 +69,15 @@ class InspectorPackagerConnection::Impl
   Impl(const Impl&) = delete;
   Impl& operator=(const Impl&) = delete;
 
-  void handleDisconnect(folly::const_dynamic_view payload);
-  void handleConnect(folly::const_dynamic_view payload);
-  void handleWrappedEvent(folly::const_dynamic_view wrappedEvent);
-  void handleProxyMessage(folly::const_dynamic_view message);
+  void handleDisconnect(const folly::const_dynamic_view& payload);
+  void handleConnect(const folly::const_dynamic_view& payload);
+  void handleWrappedEvent(const folly::const_dynamic_view& payload);
+  void handleProxyMessage(const folly::const_dynamic_view& message);
   folly::dynamic pages();
   void reconnect();
   void closeAllConnections();
   void disposeWebSocket();
-  void sendToPackager(folly::dynamic message);
+  void sendToPackager(const folly::dynamic& message);
 
   void abort(
       std::optional<int> posixCode,

package/ReactCommon/jsinspector-modern/InspectorUtilities.cpp

@@ -24,6 +24,14 @@ void CallbackLocalConnection::disconnect() {
   handler_ = nullptr;
 }
 
+CallbackRemoteConnection::CallbackRemoteConnection(
+    std::function<void(std::string)> handler)
+    : handler_(std::move(handler)) {}
+
+void CallbackRemoteConnection::onMessage(std::string message) {
+  handler_(std::move(message));
+}
+
 RAIIRemoteConnection::RAIIRemoteConnection(
     std::unique_ptr<IRemoteConnection> remote)
     : remote_(std::move(remote)) {}

package/ReactCommon/jsinspector-modern/InspectorUtilities.h

@@ -33,6 +33,25 @@ class CallbackLocalConnection : public ILocalConnection {
   std::function<void(std::string)> handler_;
 };
 
+/**
+ * Wraps a callback function in IRemoteConnection.
+ */
+class CallbackRemoteConnection : public IRemoteConnection {
+ public:
+  /**
+   * Creates a new Connection that uses the given callback to receive messages
+   * from the backend.
+   */
+  explicit CallbackRemoteConnection(std::function<void(std::string)> handler);
+
+  void onMessage(std::string message) override;
+
+  void onDisconnect() override {}
+
+ private:
+  std::function<void(std::string)> handler_;
+};
+
 /**
  * Wraps an IRemoteConnection in a simpler interface that calls `onDisconnect`
  * implicitly upon destruction.

package/ReactCommon/jsinspector-modern/InstanceAgent.cpp

@@ -9,14 +9,26 @@
 #include "RuntimeTarget.h"
 
 #include <jsinspector-modern/cdp/CdpJson.h>
+#include <jsinspector-modern/tracing/PerformanceTracer.h>
+
+#include <utility>
 
 namespace facebook::react::jsinspector_modern {
 
+namespace {
+
+// The size of the timeline for the trace recording that happened in the
+// background.
+constexpr HighResDuration kBackgroundTracePerformanceTracerWindowSize =
+    HighResDuration::fromMilliseconds(20000);
+
+} // namespace
+
 InstanceAgent::InstanceAgent(
     FrontendChannel frontendChannel,
     InstanceTarget& target,
     SessionState& sessionState)
-    : frontendChannel_(frontendChannel),
+    : frontendChannel_(std::move(frontendChannel)),
       target_(target),
       sessionState_(sessionState) {
   (void)target_;
@@ -36,7 +48,7 @@ bool InstanceAgent::handleRequest(const cdp::PreparsedRequest& req) {
 
 void InstanceAgent::setCurrentRuntime(RuntimeTarget* runtimeTarget) {
   auto previousRuntimeAgent = std::move(runtimeAgent_);
-  if (runtimeTarget) {
+  if (runtimeTarget != nullptr) {
     runtimeAgent_ = runtimeTarget->createAgent(frontendChannel_, sessionState_);
   } else {
     runtimeAgent_.reset();
@@ -153,24 +165,34 @@ void InstanceAgent::maybeSendPendingConsoleMessages() {
   }
 }
 
-void InstanceAgent::startTracing() {
-  if (runtimeAgent_) {
-    runtimeAgent_->registerForTracing();
-    runtimeAgent_->enableSamplingProfiler();
+#pragma mark - Tracing
+
+InstanceTracingAgent::InstanceTracingAgent(tracing::TraceRecordingState& state)
+    : tracing::TargetTracingAgent(state) {
+  auto& performanceTracer = tracing::PerformanceTracer::getInstance();
+  if (state.mode == tracing::Mode::Background) {
+    performanceTracer.startTracing(kBackgroundTracePerformanceTracerWindowSize);
+  } else {
+    performanceTracer.startTracing();
   }
 }
 
-void InstanceAgent::stopTracing() {
-  if (runtimeAgent_) {
-    runtimeAgent_->disableSamplingProfiler();
+InstanceTracingAgent::~InstanceTracingAgent() {
+  auto& performanceTracer = tracing::PerformanceTracer::getInstance();
+  auto performanceTraceEvents = performanceTracer.stopTracing();
+  if (performanceTraceEvents) {
+    state_.instanceTracingProfiles.emplace_back(tracing::InstanceTracingProfile{
+        .performanceTraceEvents = std::move(*performanceTraceEvents),
+    });
   }
 }
 
-tracing::InstanceTracingProfile InstanceAgent::collectTracingProfile() {
-  tracing::RuntimeSamplingProfile runtimeSamplingProfile =
-      runtimeAgent_->collectSamplingProfile();
-
-  return tracing::InstanceTracingProfile{std::move(runtimeSamplingProfile)};
+void InstanceTracingAgent::setTracedRuntime(RuntimeTarget* runtimeTarget) {
+  if (runtimeTarget != nullptr) {
+    runtimeTracingAgent_ = runtimeTarget->createTracingAgent(state_);
+  } else {
+    runtimeTracingAgent_ = nullptr;
+  }
 }
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceAgent.h

@@ -15,6 +15,7 @@
 #include <jsinspector-modern/RuntimeAgent.h>
 #include <jsinspector-modern/cdp/CdpJson.h>
 #include <jsinspector-modern/tracing/InstanceTracingProfile.h>
+#include <jsinspector-modern/tracing/TargetTracingAgent.h>
 
 #include <functional>
 
@@ -59,23 +60,6 @@ class InstanceAgent final {
    */
   void sendConsoleMessage(SimpleConsoleMessage message);
 
-  /**
-   * Notify Instance about started Tracing session. Should be initiated by
-   * TracingAgent on Tracing.start CDP method.
-   */
-  void startTracing();
-
-  /**
-   * Notify Instance about stopped Tracing session. Should be initiated by
-   * TracingAgent on Tracing.end CDP method.
-   */
-  void stopTracing();
-
-  /**
-   * Return recorded profile for the previous tracing session.
-   */
-  tracing::InstanceTracingProfile collectTracingProfile();
-
  private:
   void maybeSendExecutionContextCreatedNotification();
   void sendConsoleMessageImmediately(SimpleConsoleMessage message);
@@ -87,4 +71,27 @@ class InstanceAgent final {
   SessionState& sessionState_;
 };
 
+#pragma mark - Tracing
+
+/**
+ * An Agent that handles Tracing events for a particular InstanceTarget.
+ *
+ * Lifetime of this agent is bound to the lifetime of the Tracing session -
+ * HostTargetTraceRecording and to the lifetime of the InstanceTarget.
+ */
+class InstanceTracingAgent : tracing::TargetTracingAgent {
+ public:
+  explicit InstanceTracingAgent(tracing::TraceRecordingState& state);
+
+  ~InstanceTracingAgent();
+
+  /**
+   * Registers the RuntimeTarget with this tracing agent.
+   */
+  void setTracedRuntime(RuntimeTarget* runtimeTarget);
+
+ private:
+  std::shared_ptr<RuntimeTracingAgent> runtimeTracingAgent_;
+};
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/InstanceTarget.cpp

@@ -10,6 +10,8 @@
 
 #include <jsinspector-modern/InstanceTarget.h>
 
+#include <utility>
+
 namespace facebook::react::jsinspector_modern {
 
 std::shared_ptr<InstanceTarget> InstanceTarget::create(
@@ -18,7 +20,7 @@ std::shared_ptr<InstanceTarget> InstanceTarget::create(
     VoidExecutor executor) {
   std::shared_ptr<InstanceTarget> instanceTarget{
       new InstanceTarget(executionContextManager, delegate)};
-  instanceTarget->setExecutor(executor);
+  instanceTarget->setExecutor(std::move(executor));
   return instanceTarget;
 }
 
@@ -30,10 +32,10 @@ InstanceTarget::InstanceTarget(
   (void)delegate_;
 }
 
-InstanceTargetDelegate::~InstanceTargetDelegate() {}
+InstanceTargetDelegate::~InstanceTargetDelegate() = default;
 
 std::shared_ptr<InstanceAgent> InstanceTarget::createAgent(
-    FrontendChannel channel,
+    const FrontendChannel& channel,
     SessionState& sessionState) {
   auto instanceAgent =
       std::make_shared<InstanceAgent>(channel, *this, sessionState);
@@ -42,12 +44,25 @@ std::shared_ptr<InstanceAgent> InstanceTarget::createAgent(
   return instanceAgent;
 }
 
+std::shared_ptr<InstanceTracingAgent> InstanceTarget::createTracingAgent(
+    tracing::TraceRecordingState& state) {
+  auto agent = std::make_shared<InstanceTracingAgent>(state);
+  agent->setTracedRuntime(currentRuntime_.get());
+  tracingAgent_ = agent;
+  return agent;
+}
+
 InstanceTarget::~InstanceTarget() {
   // Agents are owned by the session, not by InstanceTarget, but
   // they hold an InstanceTarget& that we must guarantee is valid.
   assert(
       agents_.empty() &&
       "InstanceAgent objects must be destroyed before their InstanceTarget. Did you call HostTarget::unregisterInstance()?");
+
+  // Tracing Agents are owned by the HostTargetTraceRecording.
+  assert(
+      tracingAgent_.expired() &&
+      "InstanceTracingAgent must be destroyed before their InstanceTarget. Did you call HostTarget::unregisterInstance()?");
 }
 
 RuntimeTarget& InstanceTarget::registerRuntime(
@@ -61,12 +76,19 @@ RuntimeTarget& InstanceTarget::registerRuntime(
           .name = "main",
           .uniqueId = std::nullopt},
       delegate,
-      jsExecutor,
+      std::move(jsExecutor),
       makeVoidExecutor(executorFromThis()));
 
   agents_.forEach([currentRuntime = &*currentRuntime_](InstanceAgent& agent) {
     agent.setCurrentRuntime(currentRuntime);
   });
+
+  if (auto tracingAgent = tracingAgent_.lock()) {
+    // Registers the Runtime for tracing, if a Trace is currently being
+    // recorded.
+    tracingAgent->setTracedRuntime(currentRuntime_.get());
+  }
+
   return *currentRuntime_;
 }
 
@@ -76,6 +98,13 @@ void InstanceTarget::unregisterRuntime(RuntimeTarget& Runtime) {
       "Invalid unregistration");
   agents_.forEach(
       [](InstanceAgent& agent) { agent.setCurrentRuntime(nullptr); });
+
+  if (auto tracingAgent = tracingAgent_.lock()) {
+    // Unregisters the Runtime for tracing, if a Trace is currently being
+    // recorded.
+    tracingAgent->setTracedRuntime(nullptr);
+  }
+
   currentRuntime_.reset();
 }
 

package/ReactCommon/jsinspector-modern/InstanceTarget.h

@@ -15,14 +15,15 @@
 
 #include <jsinspector-modern/InspectorInterfaces.h>
 #include <jsinspector-modern/RuntimeAgent.h>
+#include <jsinspector-modern/tracing/TraceRecordingState.h>
 
-#include <list>
 #include <memory>
-#include <optional>
 
 namespace facebook::react::jsinspector_modern {
 
 class InstanceAgent;
+class InstanceTracingAgent;
+class HostTargetTraceRecording;
 
 /**
  * Receives events from an InstanceTarget. This is a shared interface that
@@ -67,9 +68,21 @@ class InstanceTarget : public EnableExecutorFromThis<InstanceTarget> {
   ~InstanceTarget();
 
   std::shared_ptr<InstanceAgent> createAgent(
-      FrontendChannel channel,
+      const FrontendChannel& channel,
       SessionState& sessionState);
 
+  /**
+   * Creates a new InstanceTracingAgent.
+   * This Agent is not owned by the InstanceTarget. The Agent will be destroyed
+   * either before the InstanceTarget is destroyed, as part of the
+   * InstanceTarget unregistration in HostTarget, or at the end of the tracing
+   * session.
+   *
+   * \param state A reference to the state of the active trace recording.
+   */
+  std::shared_ptr<InstanceTracingAgent> createTracingAgent(
+      tracing::TraceRecordingState& state);
+
   /**
    * Registers a JS runtime with this InstanceTarget. \returns a reference to
    * the created RuntimeTarget, which is owned by the \c InstanceTarget. All the
@@ -105,6 +118,13 @@ class InstanceTarget : public EnableExecutorFromThis<InstanceTarget> {
   std::shared_ptr<RuntimeTarget> currentRuntime_{nullptr};
   WeakList<InstanceAgent> agents_;
   std::shared_ptr<ExecutionContextManager> executionContextManager_;
+
+  /**
+   * This TracingAgent is owned by the HostTracingAgent, both are bound to
+   * the lifetime of their corresponding targets and the lifetime of the tracing
+   * session - HostTargetTraceRecording.
+   */
+  std::weak_ptr<InstanceTracingAgent> tracingAgent_;
 };
 
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/NetworkIOAgent.cpp

@@ -22,6 +22,7 @@ namespace facebook::react::jsinspector_modern {
 
 static constexpr long DEFAULT_BYTES_PER_READ =
     1048576; // 1MB (Chrome v112 default)
+static constexpr unsigned long MAX_BYTES_PER_READ = 10485760; // 10MB
 
 // https://github.com/chromium/chromium/blob/128.0.6593.1/content/browser/devtools/devtools_io_context.cc#L71-L73
 static constexpr std::array kTextMIMETypePrefixes{
@@ -59,7 +60,7 @@ class Stream : public NetworkRequestListener,
   Stream(const Stream& other) = delete;
   Stream& operator=(const Stream& other) = delete;
   Stream(Stream&& other) = default;
-  Stream& operator=(Stream&& other) = default;
+  Stream& operator=(Stream&& other) noexcept = default;
 
   /**
    * Factory method to create a Stream with a callback for the initial result
@@ -72,9 +73,9 @@ class Stream : public NetworkRequestListener,
    */
   static std::shared_ptr<Stream> create(
       VoidExecutor executor,
-      StreamInitCallback initCb) {
+      const StreamInitCallback& initCb) {
     std::shared_ptr<Stream> stream{new Stream(initCb)};
-    stream->setExecutor(executor);
+    stream->setExecutor(std::move(executor));
     return stream;
   }
 
@@ -87,8 +88,7 @@ class Stream : public NetworkRequestListener,
    * with the result of the read, or an error string.
    */
   void read(long maxBytesToRead, const IOReadCallback& callback) {
-    pendingReadRequests_.emplace_back(
-        std::make_tuple(maxBytesToRead, callback));
+    pendingReadRequests_.emplace_back(maxBytesToRead, callback);
     processPending();
   }
 
@@ -404,9 +404,17 @@ void NetworkIOAgent::handleIoRead(const cdp::PreparsedRequest& req) {
         "Invalid params: handle is missing or not a string."));
     return;
   }
-  std::optional<unsigned long> size = std::nullopt;
+  std::optional<int64_t> size = std::nullopt;
   if ((req.params.count("size") != 0u) && req.params.at("size").isInt()) {
     size = req.params.at("size").asInt();
+
+    if (size > MAX_BYTES_PER_READ) {
+      frontendChannel_(cdp::jsonError(
+          requestId,
+          cdp::ErrorCode::InvalidParams,
+          "Invalid params: size cannot be greater than 10MB."));
+      return;
+    }
   }
 
   auto streamId = req.params.at("handle").asString();

package/ReactCommon/jsinspector-modern/PerfMonitorV2.cpp

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ */
+
+#include "PerfMonitorV2.h"
+#include "HostTarget.h"
+
+#include <folly/json.h>
+#include <react/timing/primitives.h>
+
+namespace facebook::react::jsinspector_modern {
+
+namespace {
+
+constexpr uint16_t MIN_DURATION = 200;
+constexpr uint16_t DEFAULT_TTL = 4000;
+constexpr uint16_t BAD_EVENT_TTL = 20000;
+
+InteractionResponsivenessScore getInteractionScore(uint16_t duration) {
+  constexpr uint16_t GOOD_THRESHOLD = 200;
+  constexpr uint16_t NEEDS_IMPROVEMENT_THRESHOLD = 500;
+
+  if (duration < GOOD_THRESHOLD) {
+    return InteractionResponsivenessScore::Good;
+  } else if (duration < NEEDS_IMPROVEMENT_THRESHOLD) {
+    return InteractionResponsivenessScore::NeedsImprovement;
+  } else {
+    return InteractionResponsivenessScore::Poor;
+  }
+}
+
+} // namespace
+
+void PerfMonitorUpdateHandler::handlePerfMetricsUpdate(
+    const std::string& message) {
+  auto payload = folly::parseJson(message);
+
+  if (payload.isObject()) {
+    if (payload["name"] != "__ReactNative__LongTask") {
+      return;
+    }
+
+    auto duration = static_cast<uint16_t>(payload["duration"].asInt());
+
+    if (duration < MIN_DURATION) {
+      return;
+    }
+
+    auto responsivenessScore = getInteractionScore(duration);
+    auto ttl = responsivenessScore == InteractionResponsivenessScore::Poor
+        ? BAD_EVENT_TTL
+        : DEFAULT_TTL;
+
+    LongTaskPayload newEvent{
+        static_cast<uint16_t>(payload["startTime"].asInt()),
+        duration,
+        responsivenessScore,
+        ttl};
+
+    if (shouldOverrideLastEvent(newEvent)) {
+      lastEvent_ = newEvent;
+      delegate_.unstable_onPerfMonitorUpdate(
+          PerfMonitorUpdateRequest{newEvent});
+    }
+  }
+}
+
+bool PerfMonitorUpdateHandler::shouldOverrideLastEvent(
+    const LongTaskPayload& newEvent) {
+  if (!lastEvent_) {
+    return true;
+  }
+
+  // Override if last event has expired
+  if (HighResTimeStamp::now().toDOMHighResTimeStamp() >
+      lastEvent_->startTime + lastEvent_->ttl) {
+    return true;
+  }
+
+  // Override if same or greater responsiveness score
+  if (newEvent.responsivenessScore >= lastEvent_->responsivenessScore) {
+    return true;
+  }
+
+  return false;
+}
+
+} // namespace facebook::react::jsinspector_modern