react-native-tvos 0.83.2-0 → 0.84.0-0

package/ReactCommon/jsinspector-modern/tests/ConsoleCreateTaskTest.cpp

@@ -0,0 +1,131 @@
+/*
+ * 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 <folly/executors/QueuedImmediateExecutor.h>
+
+#include "JsiIntegrationTest.h"
+#include "engines/JsiIntegrationTestHermesEngineAdapter.h"
+
+#include <jsinspector-modern/ConsoleTaskOrchestrator.h>
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * A test fixture for the console.createTask API.
+ */
+class ConsoleCreateTaskTest : public JsiIntegrationPortableTestBase<
+                                  JsiIntegrationTestHermesEngineAdapter,
+                                  folly::QueuedImmediateExecutor> {};
+
+TEST_F(ConsoleCreateTaskTest, Installed) {
+  auto result = eval("typeof console.createTask");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_EQ(result.asString(runtime).utf8(runtime), "function");
+}
+
+TEST_F(ConsoleCreateTaskTest, ReturnsTaskObject) {
+  auto result = eval("typeof console.createTask('test-task')");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_EQ(result.asString(runtime).utf8(runtime), "object");
+}
+
+TEST_F(ConsoleCreateTaskTest, TaskObjectHasRunMethod) {
+  auto result = eval("typeof console.createTask('test-task').run");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_EQ(result.asString(runtime).utf8(runtime), "function");
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodExecutesFunction) {
+  auto result = eval(R"(
+    let executed = false;
+    const task = console.createTask('test-task');
+    task.run(() => { executed = true; });
+    executed;
+  )");
+  EXPECT_TRUE(result.getBool());
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodReturnsValue) {
+  auto result = eval(R"(
+    const task = console.createTask('test-task');
+    task.run(() => 42);
+  )");
+  EXPECT_EQ(result.getNumber(), 42);
+}
+
+TEST_F(ConsoleCreateTaskTest, ThrowsOnNoArguments) {
+  EXPECT_THROW(eval("console.createTask()"), facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, ThrowsOnEmptyString) {
+  EXPECT_THROW(eval("console.createTask('')"), facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, ThrowsOnNonStringArgument) {
+  EXPECT_THROW(eval("console.createTask(123)"), facebook::jsi::JSError);
+  EXPECT_THROW(eval("console.createTask(null)"), facebook::jsi::JSError);
+  EXPECT_THROW(eval("console.createTask(undefined)"), facebook::jsi::JSError);
+  EXPECT_THROW(eval("console.createTask({})"), facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodThrowsOnNoArguments) {
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run();
+  )"),
+      facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, RunMethodThrowsOnNonFunction) {
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run(123);
+  )"),
+      facebook::jsi::JSError);
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run('not a function');
+  )"),
+      facebook::jsi::JSError);
+  EXPECT_THROW(
+      eval(R"(
+    const task = console.createTask('test-task');
+    task.run({});
+  )"),
+      facebook::jsi::JSError);
+}
+
+TEST_F(ConsoleCreateTaskTest, MultipleTasksCanBeCreated) {
+  auto result = eval(R"(
+    const task1 = console.createTask('task-1');
+    const task2 = console.createTask('task-2');
+    let count = 0;
+    task1.run(() => { count++; });
+    task2.run(() => { count++; });
+    count;
+  )");
+  EXPECT_EQ(result.getNumber(), 2);
+}
+
+TEST_F(ConsoleCreateTaskTest, TaskCanBeRunMultipleTimes) {
+  auto result = eval(R"(
+    const task = console.createTask('test-task');
+    let count = 0;
+    task.run(() => { count++; });
+    task.run(() => { count++; });
+    task.run(() => { count++; });
+    count;
+  )");
+  EXPECT_EQ(result.getNumber(), 3);
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/HostTargetTest.cpp

@@ -1526,4 +1526,57 @@ TEST_F(HostTargetTest, IOReadSizeValidation) {
       })");
 }
 
+TEST_F(HostTargetTest, TracingDelegateIsNotifiedOnCDPRequest) {
+  connect();
+  InSequence s;
+
+  EXPECT_CALL(
+      hostTargetDelegate_.getTracingDelegateMock(),
+      onTracingStarted(Eq(tracing::Mode::CDP), Eq(false)))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(fromPage(), onMessage(JsonEq(R"({
+                                               "id": 1,
+                                               "result": {}
+                                             })")));
+  toPage_->sendMessage(R"({
+                        "id": 1,
+                        "method": "Tracing.start"
+                      })");
+
+  EXPECT_CALL(hostTargetDelegate_.getTracingDelegateMock(), onTracingStopped())
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(fromPage(), onMessage(JsonEq(R"({
+                                               "id": 1,
+                                               "result": {}
+                                             })")));
+  EXPECT_CALL(
+      fromPage(),
+      onMessage(JsonParsed(
+          testing::AllOf(
+              AtJsonPtr("/method", "Tracing.tracingComplete"),
+              AtJsonPtr("/params/dataLossOccurred", false)))));
+  toPage_->sendMessage(R"({
+                        "id": 1,
+                        "method": "Tracing.end"
+                      })");
+}
+
+TEST_F(HostTargetTest, TracingDelegateIsNotifiedOnDirectTracingCall) {
+  connect();
+
+  EXPECT_CALL(
+      hostTargetDelegate_.getTracingDelegateMock(),
+      onTracingStarted(Eq(tracing::Mode::Background), Eq(false)))
+      .Times(1)
+      .RetiresOnSaturation();
+  page_->startTracing(tracing::Mode::Background, {});
+
+  EXPECT_CALL(hostTargetDelegate_.getTracingDelegateMock(), onTracingStopped())
+      .Times(1)
+      .RetiresOnSaturation();
+  page_->stopTracing();
+}
+
 } // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/InspectorMocks.h

@@ -113,6 +113,12 @@ class MockInspectorPackagerConnectionDelegate : public InspectorPackagerConnecti
   folly::Executor &executor_;
 };
 
+class MockHostTargetTracingDelegate : public HostTargetTracingDelegate {
+ public:
+  MOCK_METHOD(void, onTracingStarted, (tracing::Mode tracingMode, bool screenshotsCategoryEnabled), (override));
+  MOCK_METHOD(void, onTracingStopped, (), (override));
+};
+
 class MockHostTargetDelegate : public HostTargetDelegate {
  public:
   // HostTargetDelegate methods
@@ -131,6 +137,20 @@ class MockHostTargetDelegate : public HostTargetDelegate {
       loadNetworkResource,
       (const LoadNetworkResourceRequest &params, ScopedExecutor<NetworkRequestListener> executor),
       (override));
+
+  HostTargetTracingDelegate *getTracingDelegate() override
+  {
+    return mockTracingDelegate_.get();
+  }
+
+  MockHostTargetTracingDelegate &getTracingDelegateMock()
+  {
+    return *mockTracingDelegate_;
+  }
+
+ private:
+  std::unique_ptr<MockHostTargetTracingDelegate> mockTracingDelegate_ =
+      std::make_unique<MockHostTargetTracingDelegate>();
 };
 
 class MockInstanceTargetDelegate : public InstanceTargetDelegate {};

package/ReactCommon/jsinspector-modern/tests/NetworkReporterTest.cpp

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-#include "JsiIntegrationTest.h"
+#include "TracingTest.h"
 #include "engines/JsiIntegrationTestHermesEngineAdapter.h"
 
 #include <folly/executors/QueuedImmediateExecutor.h>
@@ -31,13 +31,13 @@ struct NetworkReporterTestParams {
  */
 template <typename Params>
   requires std::convertible_to<Params, NetworkReporterTestParams>
-class NetworkReporterTestBase : public JsiIntegrationPortableTestBase<
+class NetworkReporterTestBase : public TracingTestBase<
                                     JsiIntegrationTestHermesEngineAdapter,
                                     folly::QueuedImmediateExecutor>,
                                 public WithParamInterface<Params> {
  protected:
   NetworkReporterTestBase()
-      : JsiIntegrationPortableTestBase({
+      : TracingTestBase({
             .networkInspectionEnabled = true,
             .enableNetworkEventReporting =
                 WithParamInterface<Params>::GetParam()
@@ -68,58 +68,6 @@ class NetworkReporterTestBase : public JsiIntegrationPortableTestBase<
         urlMatcher);
   }
 
-  void startTracing() {
-    this->expectMessageFromPage(JsonEq(R"({
-                                          "id": 1,
-                                          "result": {}
-                                        })"));
-
-    this->toPage_->sendMessage(R"({
-                                  "id": 1,
-                                  "method": "Tracing.start"
-                                })");
-  }
-
-  /**
-   * Helper method to end tracing and collect all trace events from potentially
-   * multiple chunked Tracing.dataCollected messages.
-   * \returns A vector containing all collected trace events
-   */
-  std::vector<folly::dynamic> endTracingAndCollectEvents() {
-    InSequence s;
-
-    this->expectMessageFromPage(JsonEq(R"({
-                                          "id": 1,
-                                          "result": {}
-                                        })"));
-
-    std::vector<folly::dynamic> allTraceEvents;
-
-    EXPECT_CALL(
-        fromPage(),
-        onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.dataCollected"))))
-        .Times(AtLeast(1))
-        .WillRepeatedly(Invoke([&allTraceEvents](const std::string& message) {
-          auto parsedMessage = folly::parseJson(message);
-          auto& events = parsedMessage.at("params").at("value");
-          allTraceEvents.insert(
-              allTraceEvents.end(),
-              std::make_move_iterator(events.begin()),
-              std::make_move_iterator(events.end()));
-        }));
-
-    this->expectMessageFromPage(JsonParsed(AllOf(
-        AtJsonPtr("/method", "Tracing.tracingComplete"),
-        AtJsonPtr("/params/dataLossOccurred", false))));
-
-    this->toPage_->sendMessage(R"({
-                                  "id": 1,
-                                  "method": "Tracing.end"
-                                })");
-
-    return allTraceEvents;
-  }
-
  private:
   std::optional<std::string> getScriptUrlById(const std::string& scriptId) {
     auto it = scriptUrlsById_.find(scriptId);
@@ -705,6 +653,13 @@ TEST_P(
         AtJsonPtr("/params/response/encodedDataLength", 1024),
         AtJsonPtr("/params/hasExtraInfo", false))));
 
+    this->expectMessageFromPage(JsonParsed(AllOf(
+        AtJsonPtr("/method", "Network.dataReceived"),
+        AtJsonPtr("/params/requestId", "trace-events-request"),
+        AtJsonPtr("/params/timestamp", Gt(0)),
+        AtJsonPtr("/params/dataLength", 512),
+        AtJsonPtr("/params/encodedDataLength", 512))));
+
     this->expectMessageFromPage(JsonParsed(AllOf(
         AtJsonPtr("/method", "Network.loadingFinished"),
         AtJsonPtr("/params/requestId", "trace-events-request"),
@@ -734,6 +689,9 @@ TEST_P(
       },
       1024);
 
+  NetworkReporter::getInstance().reportDataReceived(
+      "trace-events-request", 512, 512);
+
   NetworkReporter::getInstance().reportResponseEnd(
       "trace-events-request", 1024);
 
@@ -783,6 +741,18 @@ TEST_P(
                   AtJsonPtr("/receiveHeadersStart", Ge(0)),
                   AtJsonPtr("/receiveHeadersEnd", Ge(0)))))));
 
+  EXPECT_THAT(
+      allTraceEvents,
+      Contains(AllOf(
+          AtJsonPtr("/name", "ResourceReceivedData"),
+          AtJsonPtr("/cat", "devtools.timeline"),
+          AtJsonPtr("/ph", "I"),
+          AtJsonPtr("/s", "t"),
+          AtJsonPtr("/tid", oscompat::getCurrentThreadId()),
+          AtJsonPtr("/pid", oscompat::getCurrentProcessId()),
+          AtJsonPtr("/args/data/requestId", "trace-events-request"),
+          AtJsonPtr("/args/data/encodedDataLength", 512))));
+
   EXPECT_THAT(
       allTraceEvents,
       Contains(AllOf(

package/ReactCommon/jsinspector-modern/tests/ReactInstanceIntegrationTest.cpp

@@ -14,6 +14,7 @@
 #include <glog/logging.h>
 #include <jsinspector-modern/InspectorFlags.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/runtime/JSRuntimeBindings.h>
 #include <react/runtime/hermes/HermesInstance.h>
 
 using namespace ::testing;

package/ReactCommon/jsinspector-modern/tests/TracingTest.cpp

@@ -0,0 +1,116 @@
+/*
+ * 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 "TracingTest.h"
+#include "engines/JsiIntegrationTestHermesEngineAdapter.h"
+
+#include <folly/executors/QueuedImmediateExecutor.h>
+#include <jsinspector-modern/InspectorFlags.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/networking/NetworkReporter.h>
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+class TracingTest : public TracingTestBase<
+                        JsiIntegrationTestHermesEngineAdapter,
+                        folly::QueuedImmediateExecutor> {
+ protected:
+  TracingTest() : TracingTestBase() {}
+
+  void SetUp() override {
+    JsiIntegrationPortableTestBase::SetUp();
+    connect();
+    EXPECT_CALL(
+        fromPage(),
+        onMessage(
+            JsonParsed(AllOf(AtJsonPtr("/method", "Debugger.scriptParsed")))))
+        .Times(AnyNumber());
+  }
+};
+
+TEST_F(TracingTest, EnablesSamplingProfilerOnlyCategoryIsSpecified) {
+  InSequence s;
+
+  startTracing({});
+  auto allTraceEvents = endTracingAndCollectEvents();
+
+  EXPECT_THAT(
+      allTraceEvents,
+      Not(Contains(AllOf(
+          AtJsonPtr("/name", "Profile"),
+          AtJsonPtr("/cat", "disabled-by-default-v8.cpu_profiler")))));
+
+  startTracing({tracing::Category::JavaScriptSampling});
+  allTraceEvents = endTracingAndCollectEvents();
+
+  EXPECT_THAT(
+      allTraceEvents,
+      Contains(AllOf(
+          AtJsonPtr("/name", "Profile"),
+          AtJsonPtr("/cat", "disabled-by-default-v8.cpu_profiler"))));
+}
+
+TEST_F(TracingTest, RecordsFrameTimings) {
+  InSequence s;
+
+  page_->startTracing(tracing::Mode::Background, {tracing::Category::Timeline});
+
+  auto now = HighResTimeStamp::now();
+  auto frameTimingSequence = tracing::FrameTimingSequence(
+      1, // id
+      11, // threadId
+      now,
+      now + HighResDuration::fromNanoseconds(10),
+      now + HighResDuration::fromNanoseconds(50));
+
+  page_->recordFrameTimings(frameTimingSequence);
+
+  auto tracingProfile = page_->stopTracing();
+  EXPECT_EQ(tracingProfile.frameTimings.size(), 1u);
+  EXPECT_EQ(tracingProfile.frameTimings[0].id, frameTimingSequence.id);
+}
+
+TEST_F(TracingTest, EmitsRecordedFrameTimingSequences) {
+  InSequence s;
+
+  startTracing();
+  auto now = HighResTimeStamp::now();
+  page_->recordFrameTimings(
+      tracing::FrameTimingSequence(
+          1, // id
+          11, // threadId
+          now,
+          now + HighResDuration::fromNanoseconds(10),
+          now + HighResDuration::fromNanoseconds(50)));
+
+  auto allTraceEvents = endTracingAndCollectEvents();
+  EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "BeginFrame")));
+  EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "Commit")));
+  EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "DrawFrame")));
+}
+
+TEST_F(TracingTest, EmitsScreenshotEventWhenScreenshotValuePassed) {
+  InSequence s;
+
+  startTracing({tracing::Category::Screenshot});
+  auto now = HighResTimeStamp::now();
+  page_->recordFrameTimings(
+      tracing::FrameTimingSequence(
+          1, // id
+          11, // threadId
+          now,
+          now + HighResDuration::fromNanoseconds(10),
+          now + HighResDuration::fromNanoseconds(50),
+          "base64EncodedScreenshotData"));
+
+  auto allTraceEvents = endTracingAndCollectEvents();
+  EXPECT_THAT(allTraceEvents, Contains(AtJsonPtr("/name", "Screenshot")));
+}
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tests/TracingTest.h

@@ -0,0 +1,95 @@
+/*
+ * 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 "FollyDynamicMatchers.h"
+#include "JsiIntegrationTest.h"
+
+#include <fmt/format.h>
+#include <folly/dynamic.h>
+#include <folly/json.h>
+#include <gmock/gmock.h>
+
+#include <set>
+#include <vector>
+
+namespace facebook::react::jsinspector_modern {
+
+/**
+ * Base test class providing tracing-related test utilities for tests.
+ */
+template <typename EngineAdapter, typename Executor>
+class TracingTestBase : public JsiIntegrationPortableTestBase<EngineAdapter, Executor> {
+ protected:
+  using JsiIntegrationPortableTestBase<EngineAdapter, Executor>::JsiIntegrationPortableTestBase;
+
+  /**
+   * Helper method to start tracing via Tracing.start CDP command.
+   */
+  void startTracing(
+      const std::set<tracing::Category> &enabledCategories = {
+          tracing::Category::HiddenTimeline,
+          tracing::Category::JavaScriptSampling,
+          tracing::Category::RuntimeExecution,
+          tracing::Category::Timeline,
+          tracing::Category::UserTiming,
+      })
+  {
+    this->expectMessageFromPage(JsonEq(R"({
+                                          "id": 1,
+                                          "result": {}
+                                        })"));
+
+    this->toPage_->sendMessage(
+        fmt::format(
+            R"({{
+              "id": 1,
+              "method": "Tracing.start",
+              "params": {{ "categories": "{0}" }}
+            }})",
+            tracing::serializeTracingCategories(enabledCategories)));
+  }
+
+  /**
+   * Helper method to end tracing and collect all trace events from potentially
+   * multiple chunked Tracing.dataCollected messages.
+   * \returns A vector containing all collected trace events
+   */
+  std::vector<folly::dynamic> endTracingAndCollectEvents()
+  {
+    testing::InSequence s;
+
+    this->expectMessageFromPage(JsonEq(R"({
+                                          "id": 1,
+                                          "result": {}
+                                        })"));
+
+    std::vector<folly::dynamic> allTraceEvents;
+
+    EXPECT_CALL(this->fromPage(), onMessage(JsonParsed(AtJsonPtr("/method", "Tracing.dataCollected"))))
+        .Times(testing::AtLeast(1))
+        .WillRepeatedly(testing::Invoke([&allTraceEvents](const std::string &message) {
+          auto parsedMessage = folly::parseJson(message);
+          auto &events = parsedMessage.at("params").at("value");
+          allTraceEvents.insert(
+              allTraceEvents.end(), std::make_move_iterator(events.begin()), std::make_move_iterator(events.end()));
+        }));
+
+    this->expectMessageFromPage(JsonParsed(
+        testing::AllOf(AtJsonPtr("/method", "Tracing.tracingComplete"), AtJsonPtr("/params/dataLossOccurred", false))));
+
+    this->toPage_->sendMessage(R"({
+                                  "id": 1,
+                                  "method": "Tracing.end"
+                                })");
+
+    return allTraceEvents;
+  }
+};
+
+} // namespace facebook::react::jsinspector_modern

package/ReactCommon/jsinspector-modern/tracing/FrameTimingSequence.h

@@ -0,0 +1,60 @@
+/*
+ * 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 "TraceEvent.h"
+
+#include <react/timing/primitives.h>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+using FrameSequenceId = uint64_t;
+
+/**
+ * A struct representing a sequence of frame timings that happened on the Host side.
+ */
+struct FrameTimingSequence {
+  FrameTimingSequence() = delete;
+
+  FrameTimingSequence(
+      FrameSequenceId id,
+      ThreadId threadId,
+      HighResTimeStamp beginDrawingTimestamp,
+      HighResTimeStamp commitTimestamp,
+      HighResTimeStamp endDrawingTimestamp,
+      std::optional<std::string> screenshot = std::nullopt)
+      : id(id),
+        threadId(threadId),
+        beginDrawingTimestamp(beginDrawingTimestamp),
+        commitTimestamp(commitTimestamp),
+        endDrawingTimestamp(endDrawingTimestamp),
+        screenshot(std::move(screenshot))
+  {
+  }
+
+  /**
+   * Unique ID of the sequence, used by Chrome DevTools Frontend to identify the events that form one sequence.
+   */
+  FrameSequenceId id;
+
+  /**
+   * The ID of the native thread that is associated with the frame.
+   */
+  ThreadId threadId;
+
+  HighResTimeStamp beginDrawingTimestamp;
+  HighResTimeStamp commitTimestamp;
+  HighResTimeStamp endDrawingTimestamp;
+
+  /**
+   * Optional screenshot data (base64 encoded) captured during the frame.
+   */
+  std::optional<std::string> screenshot;
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing

package/ReactCommon/jsinspector-modern/tracing/HostTracingProfile.h

@@ -0,0 +1,43 @@
+/*
+ * 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 "FrameTimingSequence.h"
+#include "InstanceTracingProfile.h"
+#include "RuntimeSamplingProfile.h"
+
+#include <react/timing/primitives.h>
+
+#include <vector>
+
+namespace facebook::react::jsinspector_modern::tracing {
+
+/**
+ * The final tracing profile for the given HostTarget.
+ * Contains all necessary information that is required to be be emitted as a series of Tracing.dataCollected CDP
+ * messages.
+ */
+struct HostTracingProfile {
+  // The ID of the OS-level process that this Trace Recording is associated
+  // with.
+  ProcessId processId;
+
+  // The timestamp at which this Trace Recording started.
+  HighResTimeStamp startTime;
+
+  // Frame timings captured on the Host side.
+  std::vector<FrameTimingSequence> frameTimings;
+
+  // All captured Instance Tracing Profiles during this Trace Recording.
+  std::vector<InstanceTracingProfile> instanceTracingProfiles;
+
+  // All captured Runtime Sampling Profiles during this Trace Recording.
+  std::vector<RuntimeSamplingProfile> runtimeSamplingProfiles;
+};
+
+} // namespace facebook::react::jsinspector_modern::tracing