react-native 0.68.2 → 0.69.0-rc.2

package/ReactCommon/hermes/inspector/chrome/MessageTypes.cpp

@@ -1,5 +1,5 @@
-// Copyright 2004-present Facebook. All Rights Reserved.
-// @generated SignedSource<<522f29c54f207a4f7b5c33af07cf64d0>>
+// Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved.
+// @generated SignedSource<<f6f9a72f332587809b4e50ab054e0a74>>
 
 #include "MessageTypes.h"
 
@@ -60,7 +60,11 @@ std::unique_ptr<Request> Request::fromJsonThrowOnError(const std::string &str) {
        makeUnique<heapProfiler::StopTrackingHeapObjectsRequest>},
       {"HeapProfiler.takeHeapSnapshot",
        makeUnique<heapProfiler::TakeHeapSnapshotRequest>},
+      {"Profiler.start", makeUnique<profiler::StartRequest>},
+      {"Profiler.stop", makeUnique<profiler::StopRequest>},
+      {"Runtime.callFunctionOn", makeUnique<runtime::CallFunctionOnRequest>},
       {"Runtime.evaluate", makeUnique<runtime::EvaluateRequest>},
+      {"Runtime.getHeapUsage", makeUnique<runtime::GetHeapUsageRequest>},
       {"Runtime.getProperties", makeUnique<runtime::GetPropertiesRequest>},
       {"Runtime.runIfWaitingForDebugger",
        makeUnique<runtime::RunIfWaitingForDebuggerRequest>},
@@ -274,6 +278,74 @@ dynamic heapProfiler::SamplingHeapProfile::toDynamic() const {
   return obj;
 }
 
+profiler::PositionTickInfo::PositionTickInfo(const dynamic &obj) {
+  assign(line, obj, "line");
+  assign(ticks, obj, "ticks");
+}
+
+dynamic profiler::PositionTickInfo::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "line", line);
+  put(obj, "ticks", ticks);
+  return obj;
+}
+
+profiler::ProfileNode::ProfileNode(const dynamic &obj) {
+  assign(id, obj, "id");
+  assign(callFrame, obj, "callFrame");
+  assign(hitCount, obj, "hitCount");
+  assign(children, obj, "children");
+  assign(deoptReason, obj, "deoptReason");
+  assign(positionTicks, obj, "positionTicks");
+}
+
+dynamic profiler::ProfileNode::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "id", id);
+  put(obj, "callFrame", callFrame);
+  put(obj, "hitCount", hitCount);
+  put(obj, "children", children);
+  put(obj, "deoptReason", deoptReason);
+  put(obj, "positionTicks", positionTicks);
+  return obj;
+}
+
+profiler::Profile::Profile(const dynamic &obj) {
+  assign(nodes, obj, "nodes");
+  assign(startTime, obj, "startTime");
+  assign(endTime, obj, "endTime");
+  assign(samples, obj, "samples");
+  assign(timeDeltas, obj, "timeDeltas");
+}
+
+dynamic profiler::Profile::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "nodes", nodes);
+  put(obj, "startTime", startTime);
+  put(obj, "endTime", endTime);
+  put(obj, "samples", samples);
+  put(obj, "timeDeltas", timeDeltas);
+  return obj;
+}
+
+runtime::CallArgument::CallArgument(const dynamic &obj) {
+  assign(value, obj, "value");
+  assign(unserializableValue, obj, "unserializableValue");
+  assign(objectId, obj, "objectId");
+}
+
+dynamic runtime::CallArgument::toDynamic() const {
+  dynamic obj = dynamic::object;
+
+  put(obj, "value", value);
+  put(obj, "unserializableValue", unserializableValue);
+  put(obj, "objectId", objectId);
+  return obj;
+}
+
 runtime::ExecutionContextDescription::ExecutionContextDescription(
     const dynamic &obj) {
   assign(id, obj, "id");
@@ -487,12 +559,22 @@ debugger::ResumeRequest::ResumeRequest(const dynamic &obj)
     : Request("Debugger.resume") {
   assign(id, obj, "id");
   assign(method, obj, "method");
+
+  auto it = obj.find("params");
+  if (it != obj.items().end()) {
+    dynamic params = it->second;
+    assign(terminateOnResume, params, "terminateOnResume");
+  }
 }
 
 dynamic debugger::ResumeRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "terminateOnResume", terminateOnResume);
+
   dynamic obj = dynamic::object;
   put(obj, "id", id);
   put(obj, "method", method);
+  put(obj, "params", std::move(params));
   return obj;
 }
 
@@ -801,8 +883,11 @@ heapProfiler::StartSamplingRequest::StartSamplingRequest(const dynamic &obj)
   assign(id, obj, "id");
   assign(method, obj, "method");
 
-  dynamic params = obj.at("params");
-  assign(samplingInterval, params, "samplingInterval");
+  auto it = obj.find("params");
+  if (it != obj.items().end()) {
+    dynamic params = it->second;
+    assign(samplingInterval, params, "samplingInterval");
+  }
 }
 
 dynamic heapProfiler::StartSamplingRequest::toDynamic() const {
@@ -829,8 +914,11 @@ heapProfiler::StartTrackingHeapObjectsRequest::StartTrackingHeapObjectsRequest(
   assign(id, obj, "id");
   assign(method, obj, "method");
 
-  dynamic params = obj.at("params");
-  assign(trackAllocations, params, "trackAllocations");
+  auto it = obj.find("params");
+  if (it != obj.items().end()) {
+    dynamic params = it->second;
+    assign(trackAllocations, params, "trackAllocations");
+  }
 }
 
 dynamic heapProfiler::StartTrackingHeapObjectsRequest::toDynamic() const {
@@ -878,15 +966,20 @@ heapProfiler::StopTrackingHeapObjectsRequest::StopTrackingHeapObjectsRequest(
   assign(id, obj, "id");
   assign(method, obj, "method");
 
-  dynamic params = obj.at("params");
-  assign(reportProgress, params, "reportProgress");
-  assign(treatGlobalObjectsAsRoots, params, "treatGlobalObjectsAsRoots");
+  auto it = obj.find("params");
+  if (it != obj.items().end()) {
+    dynamic params = it->second;
+    assign(reportProgress, params, "reportProgress");
+    assign(treatGlobalObjectsAsRoots, params, "treatGlobalObjectsAsRoots");
+    assign(captureNumericValue, params, "captureNumericValue");
+  }
 }
 
 dynamic heapProfiler::StopTrackingHeapObjectsRequest::toDynamic() const {
   dynamic params = dynamic::object;
   put(params, "reportProgress", reportProgress);
   put(params, "treatGlobalObjectsAsRoots", treatGlobalObjectsAsRoots);
+  put(params, "captureNumericValue", captureNumericValue);
 
   dynamic obj = dynamic::object;
   put(obj, "id", id);
@@ -909,15 +1002,20 @@ heapProfiler::TakeHeapSnapshotRequest::TakeHeapSnapshotRequest(
   assign(id, obj, "id");
   assign(method, obj, "method");
 
-  dynamic params = obj.at("params");
-  assign(reportProgress, params, "reportProgress");
-  assign(treatGlobalObjectsAsRoots, params, "treatGlobalObjectsAsRoots");
+  auto it = obj.find("params");
+  if (it != obj.items().end()) {
+    dynamic params = it->second;
+    assign(reportProgress, params, "reportProgress");
+    assign(treatGlobalObjectsAsRoots, params, "treatGlobalObjectsAsRoots");
+    assign(captureNumericValue, params, "captureNumericValue");
+  }
 }
 
 dynamic heapProfiler::TakeHeapSnapshotRequest::toDynamic() const {
   dynamic params = dynamic::object;
   put(params, "reportProgress", reportProgress);
   put(params, "treatGlobalObjectsAsRoots", treatGlobalObjectsAsRoots);
+  put(params, "captureNumericValue", captureNumericValue);
 
   dynamic obj = dynamic::object;
   put(obj, "id", id);
@@ -931,6 +1029,87 @@ void heapProfiler::TakeHeapSnapshotRequest::accept(
   handler.handle(*this);
 }
 
+profiler::StartRequest::StartRequest() : Request("Profiler.start") {}
+
+profiler::StartRequest::StartRequest(const dynamic &obj)
+    : Request("Profiler.start") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+}
+
+dynamic profiler::StartRequest::toDynamic() const {
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  return obj;
+}
+
+void profiler::StartRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+profiler::StopRequest::StopRequest() : Request("Profiler.stop") {}
+
+profiler::StopRequest::StopRequest(const dynamic &obj)
+    : Request("Profiler.stop") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+}
+
+dynamic profiler::StopRequest::toDynamic() const {
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  return obj;
+}
+
+void profiler::StopRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
+runtime::CallFunctionOnRequest::CallFunctionOnRequest()
+    : Request("Runtime.callFunctionOn") {}
+
+runtime::CallFunctionOnRequest::CallFunctionOnRequest(const dynamic &obj)
+    : Request("Runtime.callFunctionOn") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+
+  dynamic params = obj.at("params");
+  assign(functionDeclaration, params, "functionDeclaration");
+  assign(objectId, params, "objectId");
+  assign(arguments, params, "arguments");
+  assign(silent, params, "silent");
+  assign(returnByValue, params, "returnByValue");
+  assign(userGesture, params, "userGesture");
+  assign(awaitPromise, params, "awaitPromise");
+  assign(executionContextId, params, "executionContextId");
+  assign(objectGroup, params, "objectGroup");
+}
+
+dynamic runtime::CallFunctionOnRequest::toDynamic() const {
+  dynamic params = dynamic::object;
+  put(params, "functionDeclaration", functionDeclaration);
+  put(params, "objectId", objectId);
+  put(params, "arguments", arguments);
+  put(params, "silent", silent);
+  put(params, "returnByValue", returnByValue);
+  put(params, "userGesture", userGesture);
+  put(params, "awaitPromise", awaitPromise);
+  put(params, "executionContextId", executionContextId);
+  put(params, "objectGroup", objectGroup);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  put(obj, "params", std::move(params));
+  return obj;
+}
+
+void runtime::CallFunctionOnRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 runtime::EvaluateRequest::EvaluateRequest() : Request("Runtime.evaluate") {}
 
 runtime::EvaluateRequest::EvaluateRequest(const dynamic &obj)
@@ -971,6 +1150,26 @@ void runtime::EvaluateRequest::accept(RequestHandler &handler) const {
   handler.handle(*this);
 }
 
+runtime::GetHeapUsageRequest::GetHeapUsageRequest()
+    : Request("Runtime.getHeapUsage") {}
+
+runtime::GetHeapUsageRequest::GetHeapUsageRequest(const dynamic &obj)
+    : Request("Runtime.getHeapUsage") {
+  assign(id, obj, "id");
+  assign(method, obj, "method");
+}
+
+dynamic runtime::GetHeapUsageRequest::toDynamic() const {
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "method", method);
+  return obj;
+}
+
+void runtime::GetHeapUsageRequest::accept(RequestHandler &handler) const {
+  handler.handle(*this);
+}
+
 runtime::GetPropertiesRequest::GetPropertiesRequest()
     : Request("Runtime.getProperties") {}
 
@@ -1187,6 +1386,42 @@ dynamic heapProfiler::StopSamplingResponse::toDynamic() const {
   return obj;
 }
 
+profiler::StopResponse::StopResponse(const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(profile, res, "profile");
+}
+
+dynamic profiler::StopResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "profile", profile);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
+runtime::CallFunctionOnResponse::CallFunctionOnResponse(const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(result, res, "result");
+  assign(exceptionDetails, res, "exceptionDetails");
+}
+
+dynamic runtime::CallFunctionOnResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "result", result);
+  put(res, "exceptionDetails", exceptionDetails);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
 runtime::EvaluateResponse::EvaluateResponse(const dynamic &obj) {
   assign(id, obj, "id");
 
@@ -1206,6 +1441,25 @@ dynamic runtime::EvaluateResponse::toDynamic() const {
   return obj;
 }
 
+runtime::GetHeapUsageResponse::GetHeapUsageResponse(const dynamic &obj) {
+  assign(id, obj, "id");
+
+  dynamic res = obj.at("result");
+  assign(usedSize, res, "usedSize");
+  assign(totalSize, res, "totalSize");
+}
+
+dynamic runtime::GetHeapUsageResponse::toDynamic() const {
+  dynamic res = dynamic::object;
+  put(res, "usedSize", usedSize);
+  put(res, "totalSize", totalSize);
+
+  dynamic obj = dynamic::object;
+  put(obj, "id", id);
+  put(obj, "result", std::move(res));
+  return obj;
+}
+
 runtime::GetPropertiesResponse::GetPropertiesResponse(const dynamic &obj) {
   assign(id, obj, "id");
 

package/ReactCommon/hermes/inspector/chrome/MessageTypes.h

@@ -1,5 +1,5 @@
-// Copyright 2004-present Facebook. All Rights Reserved.
-// @generated SignedSource<<a541d174394c8959b9fb6a7c575e7040>>
+// Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved.
+// @generated SignedSource<<fcbcfeecbc72ca30c8ed005ad47839bb>>
 
 #pragma once
 
@@ -48,7 +48,10 @@ struct StepOverRequest;
 } // namespace debugger
 
 namespace runtime {
+struct CallArgument;
 struct CallFrame;
+struct CallFunctionOnRequest;
+struct CallFunctionOnResponse;
 struct ConsoleAPICalledNotification;
 struct EvaluateRequest;
 struct EvaluateResponse;
@@ -56,6 +59,8 @@ struct ExceptionDetails;
 struct ExecutionContextCreatedNotification;
 struct ExecutionContextDescription;
 using ExecutionContextId = int;
+struct GetHeapUsageRequest;
+struct GetHeapUsageResponse;
 struct GetPropertiesRequest;
 struct GetPropertiesResponse;
 struct InternalPropertyDescriptor;
@@ -91,6 +96,15 @@ struct StopTrackingHeapObjectsRequest;
 struct TakeHeapSnapshotRequest;
 } // namespace heapProfiler
 
+namespace profiler {
+struct PositionTickInfo;
+struct Profile;
+struct ProfileNode;
+struct StartRequest;
+struct StopRequest;
+struct StopResponse;
+} // namespace profiler
+
 /// RequestHandler handles requests via the visitor pattern.
 struct RequestHandler {
   virtual ~RequestHandler() = default;
@@ -122,7 +136,11 @@ struct RequestHandler {
   virtual void handle(
       const heapProfiler::StopTrackingHeapObjectsRequest &req) = 0;
   virtual void handle(const heapProfiler::TakeHeapSnapshotRequest &req) = 0;
+  virtual void handle(const profiler::StartRequest &req) = 0;
+  virtual void handle(const profiler::StopRequest &req) = 0;
+  virtual void handle(const runtime::CallFunctionOnRequest &req) = 0;
   virtual void handle(const runtime::EvaluateRequest &req) = 0;
+  virtual void handle(const runtime::GetHeapUsageRequest &req) = 0;
   virtual void handle(const runtime::GetPropertiesRequest &req) = 0;
   virtual void handle(const runtime::RunIfWaitingForDebuggerRequest &req) = 0;
 };
@@ -156,7 +174,11 @@ struct NoopRequestHandler : public RequestHandler {
   void handle(
       const heapProfiler::StopTrackingHeapObjectsRequest &req) override {}
   void handle(const heapProfiler::TakeHeapSnapshotRequest &req) override {}
+  void handle(const profiler::StartRequest &req) override {}
+  void handle(const profiler::StopRequest &req) override {}
+  void handle(const runtime::CallFunctionOnRequest &req) override {}
   void handle(const runtime::EvaluateRequest &req) override {}
+  void handle(const runtime::GetHeapUsageRequest &req) override {}
   void handle(const runtime::GetPropertiesRequest &req) override {}
   void handle(const runtime::RunIfWaitingForDebuggerRequest &req) override {}
 };
@@ -281,6 +303,50 @@ struct heapProfiler::SamplingHeapProfile : public Serializable {
   std::vector<heapProfiler::SamplingHeapProfileSample> samples;
 };
 
+struct profiler::PositionTickInfo : public Serializable {
+  PositionTickInfo() = default;
+  explicit PositionTickInfo(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  int line{};
+  int ticks{};
+};
+
+struct profiler::ProfileNode : public Serializable {
+  ProfileNode() = default;
+  explicit ProfileNode(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  int id{};
+  runtime::CallFrame callFrame{};
+  folly::Optional<int> hitCount;
+  folly::Optional<std::vector<int>> children;
+  folly::Optional<std::string> deoptReason;
+  folly::Optional<std::vector<profiler::PositionTickInfo>> positionTicks;
+};
+
+struct profiler::Profile : public Serializable {
+  Profile() = default;
+  explicit Profile(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  std::vector<profiler::ProfileNode> nodes;
+  double startTime{};
+  double endTime{};
+  folly::Optional<std::vector<int>> samples;
+  folly::Optional<std::vector<int>> timeDeltas;
+};
+
+struct runtime::CallArgument : public Serializable {
+  CallArgument() = default;
+  explicit CallArgument(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  folly::Optional<folly::dynamic> value;
+  folly::Optional<runtime::UnserializableValue> unserializableValue;
+  folly::Optional<runtime::RemoteObjectId> objectId;
+};
+
 struct runtime::ExecutionContextDescription : public Serializable {
   ExecutionContextDescription() = default;
   explicit ExecutionContextDescription(const folly::dynamic &obj);
@@ -385,6 +451,8 @@ struct debugger::ResumeRequest : public Request {
 
   folly::dynamic toDynamic() const override;
   void accept(RequestHandler &handler) const override;
+
+  folly::Optional<bool> terminateOnResume;
 };
 
 struct debugger::SetBreakpointRequest : public Request {
@@ -533,6 +601,7 @@ struct heapProfiler::StopTrackingHeapObjectsRequest : public Request {
 
   folly::Optional<bool> reportProgress;
   folly::Optional<bool> treatGlobalObjectsAsRoots;
+  folly::Optional<bool> captureNumericValue;
 };
 
 struct heapProfiler::TakeHeapSnapshotRequest : public Request {
@@ -544,6 +613,41 @@ struct heapProfiler::TakeHeapSnapshotRequest : public Request {
 
   folly::Optional<bool> reportProgress;
   folly::Optional<bool> treatGlobalObjectsAsRoots;
+  folly::Optional<bool> captureNumericValue;
+};
+
+struct profiler::StartRequest : public Request {
+  StartRequest();
+  explicit StartRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+};
+
+struct profiler::StopRequest : public Request {
+  StopRequest();
+  explicit StopRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+};
+
+struct runtime::CallFunctionOnRequest : public Request {
+  CallFunctionOnRequest();
+  explicit CallFunctionOnRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+
+  std::string functionDeclaration;
+  folly::Optional<runtime::RemoteObjectId> objectId;
+  folly::Optional<std::vector<runtime::CallArgument>> arguments;
+  folly::Optional<bool> silent;
+  folly::Optional<bool> returnByValue;
+  folly::Optional<bool> userGesture;
+  folly::Optional<bool> awaitPromise;
+  folly::Optional<runtime::ExecutionContextId> executionContextId;
+  folly::Optional<std::string> objectGroup;
 };
 
 struct runtime::EvaluateRequest : public Request {
@@ -563,6 +667,14 @@ struct runtime::EvaluateRequest : public Request {
   folly::Optional<bool> awaitPromise;
 };
 
+struct runtime::GetHeapUsageRequest : public Request {
+  GetHeapUsageRequest();
+  explicit GetHeapUsageRequest(const folly::dynamic &obj);
+
+  folly::dynamic toDynamic() const override;
+  void accept(RequestHandler &handler) const override;
+};
+
 struct runtime::GetPropertiesRequest : public Request {
   GetPropertiesRequest();
   explicit GetPropertiesRequest(const folly::dynamic &obj);
@@ -658,6 +770,23 @@ struct heapProfiler::StopSamplingResponse : public Response {
   heapProfiler::SamplingHeapProfile profile{};
 };
 
+struct profiler::StopResponse : public Response {
+  StopResponse() = default;
+  explicit StopResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  profiler::Profile profile{};
+};
+
+struct runtime::CallFunctionOnResponse : public Response {
+  CallFunctionOnResponse() = default;
+  explicit CallFunctionOnResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  runtime::RemoteObject result{};
+  folly::Optional<runtime::ExceptionDetails> exceptionDetails;
+};
+
 struct runtime::EvaluateResponse : public Response {
   EvaluateResponse() = default;
   explicit EvaluateResponse(const folly::dynamic &obj);
@@ -667,6 +796,15 @@ struct runtime::EvaluateResponse : public Response {
   folly::Optional<runtime::ExceptionDetails> exceptionDetails;
 };
 
+struct runtime::GetHeapUsageResponse : public Response {
+  GetHeapUsageResponse() = default;
+  explicit GetHeapUsageResponse(const folly::dynamic &obj);
+  folly::dynamic toDynamic() const override;
+
+  double usedSize{};
+  double totalSize{};
+};
+
 struct runtime::GetPropertiesResponse : public Response {
   GetPropertiesResponse() = default;
   explicit GetPropertiesResponse(const folly::dynamic &obj);

package/ReactCommon/hermes/inspector/chrome/tests/AsyncHermesRuntime.cpp

@@ -139,6 +139,27 @@ std::string AsyncHermesRuntime::getLastThrownExceptionMessage() {
   return thrownExceptions_.back();
 }
 
+void AsyncHermesRuntime::registerForProfilingInExecutor() {
+  // Sampling profiler registration needs to happen in the thread where JS runs.
+  folly::via(executor_.get(), [runtime = runtime_]() {
+    runtime->registerForProfiling();
+  });
+
+  // Wait until the executor is registered for profiling.
+  wait();
+}
+
+void AsyncHermesRuntime::unregisterForProfilingInExecutor() {
+  // Sampling profiler deregistration needs to happen in the thread where JS
+  // runs.
+  folly::via(executor_.get(), [runtime = runtime_]() {
+    runtime->unregisterForProfiling();
+  });
+
+  // Wait until the executor is unregistered for profiling.
+  wait();
+}
+
 } // namespace chrome
 } // namespace inspector
 } // namespace hermes

package/ReactCommon/hermes/inspector/chrome/tests/AsyncHermesRuntime.h

@@ -95,6 +95,16 @@ class AsyncHermesRuntime {
    */
   std::string getLastThrownExceptionMessage();
 
+  /**
+   * registers the runtime for profiling in the executor thread.
+   */
+  void registerForProfilingInExecutor();
+
+  /**
+   * unregisters the runtime for profiling in the executor thread.
+   */
+  void unregisterForProfilingInExecutor();
+
  private:
   jsi::Value shouldStop(
       jsi::Runtime &runtime,
@@ -115,6 +125,23 @@ class AsyncHermesRuntime {
   std::vector<std::string> thrownExceptions_;
 };
 
+/// RAII-style class dealing with sampling profiler registration in tests. This
+/// is especially important in tests -- if any test failure is caused by an
+/// uncaught exception, stack unwinding will destroy a VM registered for
+/// profiling in a thread that's not the one where registration happened, which
+/// will lead to a hermes fatal error. Using this RAII class ensure that the
+/// proper test failure cause is reported.
+struct SamplingProfilerRAII {
+  explicit SamplingProfilerRAII(AsyncHermesRuntime &rt) : runtime_(rt) {
+    runtime_.registerForProfilingInExecutor();
+  }
+
+  ~SamplingProfilerRAII() {
+    runtime_.unregisterForProfilingInExecutor();
+  }
+
+  AsyncHermesRuntime &runtime_;
+};
 } // namespace chrome
 } // namespace inspector
 } // namespace hermes