react-native-windows 0.71.24 → 0.71.25

package/Shared/HermesRuntimeHolder.cpp

@@ -3,134 +3,394 @@
 
 #include "pch.h"
 
-#include <memory>
-#include <mutex>
+#include "HermesRuntimeHolder.h"
 
+#include <ApiLoaders/HermesApi.h>
 #include <JSI/decorator.h>
-#include <cxxreact/MessageQueueThread.h>
+#include <NodeApiJsiRuntime.h>
+#include <crash/verifyElseCrash.h>
 #include <cxxreact/SystraceSection.h>
-#include <hermes/hermes.h>
-#include "HermesRuntimeHolder.h"
-#include "HermesShim.h"
+#include <jsinspector/InspectorInterfaces.h>
+#include <mutex>
+#include "SafeLoadLibrary.h"
 
-#if defined(HERMES_ENABLE_DEBUGGER)
-#include <hermes/inspector/chrome/Registration.h>
-#endif
+#define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
 
-using namespace facebook;
-using namespace Microsoft::ReactNative;
+namespace React {
+using namespace winrt::Microsoft::ReactNative;
+}
+
+using namespace Microsoft::NodeApiJsi;
 
-namespace facebook {
-namespace react {
+namespace Microsoft::ReactNative {
+
+React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>>
+HermesRuntimeHolderProperty() noexcept {
+  static React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>> propId{
+      L"ReactNative.HermesRuntimeHolder", L"HermesRuntimeHolder"};
+  return propId;
+}
 
 namespace {
 
-std::unique_ptr<facebook::hermes::HermesRuntime> makeHermesRuntimeSystraced(bool enableDefaultCrashHandler) {
-  SystraceSection s("HermesExecutorFactory::makeHermesRuntimeSystraced");
-  if (enableDefaultCrashHandler) {
-    return HermesShim::makeHermesRuntimeWithWER();
-  } else {
-    auto runtimeConfig = ::hermes::vm::RuntimeConfig();
-    return HermesShim::makeHermesRuntime(runtimeConfig);
+int32_t NAPI_CDECL addInspectorPage(const char *title, const char *vm, void *connectFunc) noexcept;
+void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept;
+
+class HermesFuncResolver : public IFuncResolver {
+ public:
+  HermesFuncResolver() : libHandle_(SafeLoadLibrary(L"hermes.dll")) {}
+
+  FuncPtr getFuncPtr(const char *funcName) override {
+    return reinterpret_cast<FuncPtr>(GetProcAddress(libHandle_, funcName));
   }
+
+ private:
+  HMODULE libHandle_;
+};
+
+HermesApi &initHermesApi() noexcept {
+  static HermesFuncResolver funcResolver;
+  static HermesApi s_hermesApi(&funcResolver);
+  HermesApi::setCurrent(&s_hermesApi);
+  CRASH_ON_ERROR(s_hermesApi.hermes_set_inspector(&addInspectorPage, &removeInspectorPage));
+  return s_hermesApi;
+}
+
+HermesApi &getHermesApi() noexcept {
+  static HermesApi &s_hermesApi = initHermesApi();
+  return s_hermesApi;
 }
 
-#ifdef HERMES_ENABLE_DEBUGGER
-class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::RuntimeAdapter {
+class HermesTask {
+ public:
+  HermesTask(
+      void *taskData,
+      jsr_task_run_cb taskRunCallback,
+      jsr_data_delete_cb taskDataDeleteCallback,
+      void *deleterData)
+      : taskData_(taskData),
+        taskRunCallback_(taskRunCallback),
+        taskDataDeleteCallback_(taskDataDeleteCallback),
+        deleterData_(deleterData) {}
+
+  HermesTask(const HermesTask &other) = delete;
+  HermesTask &operator=(const HermesTask &other) = delete;
+
+  ~HermesTask() {
+    if (taskDataDeleteCallback_ != nullptr) {
+      taskDataDeleteCallback_(taskData_, deleterData_);
+    }
+  }
+
+  void Run() const {
+    if (taskRunCallback_ != nullptr) {
+      taskRunCallback_(taskData_);
+    }
+  }
+
+ private:
+  void *taskData_;
+  jsr_task_run_cb taskRunCallback_;
+  jsr_data_delete_cb taskDataDeleteCallback_;
+  void *deleterData_;
+};
+
+class HermesTaskRunner {
+ public:
+  static void Create(jsr_config config, std::shared_ptr<facebook::react::MessageQueueThread> queue) {
+    CRASH_ON_ERROR(getHermesApi().jsr_config_set_task_runner(
+        config, new HermesTaskRunner(std::move(queue)), &PostTask, &Delete, nullptr));
+  }
+
+ private:
+  HermesTaskRunner(std::shared_ptr<facebook::react::MessageQueueThread> queue) : queue_(std::move(queue)) {}
+
+  static void NAPI_CDECL PostTask(
+      void *taskRunnerData,
+      void *taskData,
+      jsr_task_run_cb taskRunCallback,
+      jsr_data_delete_cb taskDataDeleteCallback,
+      void *deleterData) {
+    auto task = std::make_shared<HermesTask>(taskData, taskRunCallback, taskDataDeleteCallback, deleterData);
+    reinterpret_cast<HermesTaskRunner *>(taskRunnerData)->queue_->runOnQueue([task = std::move(task)] { task->Run(); });
+  }
+
+  static void NAPI_CDECL Delete(void *taskRunner, void * /*deleterData*/) {
+    delete reinterpret_cast<HermesTaskRunner *>(taskRunner);
+  }
+
+ private:
+  std::shared_ptr<facebook::react::MessageQueueThread> queue_;
+};
+
+struct HermesJsiBuffer : facebook::jsi::Buffer {
+  static std::shared_ptr<const facebook::jsi::Buffer>
+  Create(const uint8_t *buffer, size_t bufferSize, jsr_data_delete_cb bufferDeleteCallback, void *deleterData) {
+    return std::shared_ptr<const facebook::jsi::Buffer>(
+        new HermesJsiBuffer(buffer, bufferSize, bufferDeleteCallback, deleterData));
+  }
+
+  HermesJsiBuffer(
+      const uint8_t *buffer,
+      size_t bufferSize,
+      jsr_data_delete_cb bufferDeleteCallback,
+      void *deleterData) noexcept
+      : buffer_(buffer),
+        bufferSize_(bufferSize),
+        bufferDeleteCallback_(bufferDeleteCallback),
+        deleterData_(deleterData) {}
+
+  ~HermesJsiBuffer() override {
+    if (bufferDeleteCallback_) {
+      bufferDeleteCallback_(const_cast<uint8_t *>(buffer_), deleterData_);
+    }
+  }
+
+  const uint8_t *data() const override {
+    return buffer_;
+  }
+
+  size_t size() const override {
+    return bufferSize_;
+  }
+
+ private:
+  const uint8_t *buffer_;
+  size_t bufferSize_;
+  jsr_data_delete_cb bufferDeleteCallback_;
+  void *deleterData_;
+};
+
+class HermesScriptCache {
  public:
-  HermesExecutorRuntimeAdapter(
-      std::shared_ptr<jsi::Runtime> runtime,
-      facebook::hermes::HermesRuntime &hermesRuntime,
-      std::shared_ptr<MessageQueueThread> thread)
-      : m_runtime(runtime), m_hermesRuntime(hermesRuntime), m_thread(std::move(thread)) {}
+  static void Create(jsr_config config, std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore) {
+    CRASH_ON_ERROR(getHermesApi().jsr_config_set_script_cache(
+        config, new HermesScriptCache(std::move(scriptStore)), &LoadScript, &StoreScript, &Delete, nullptr));
+  }
 
-  virtual ~HermesExecutorRuntimeAdapter() = default;
+ private:
+  HermesScriptCache(std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore)
+      : scriptStore_(std::move(scriptStore)) {}
+
+  static void NAPI_CDECL LoadScript(
+      void *scriptCache,
+      const char *sourceUrl,
+      uint64_t sourceHash,
+      const char *runtimeName,
+      uint64_t runtimeVersion,
+      const char *cacheTag,
+      const uint8_t **buffer,
+      size_t *bufferSize,
+      jsr_data_delete_cb *bufferDeleteCallback,
+      void **deleterData) {
+    auto &scriptStore = reinterpret_cast<HermesScriptCache *>(scriptCache)->scriptStore_;
+    std::shared_ptr<const facebook::jsi::Buffer> preparedScript = scriptStore->tryGetPreparedScript(
+        facebook::jsi::ScriptSignature{sourceUrl, sourceHash},
+        facebook::jsi::JSRuntimeSignature{runtimeName, runtimeVersion},
+        cacheTag);
+    if (preparedScript) {
+      *buffer = preparedScript->data();
+      *bufferSize = preparedScript->size();
+      *bufferDeleteCallback = [](void * /*data*/, void *deleterData) noexcept {
+        delete reinterpret_cast<std::shared_ptr<const facebook::jsi::Buffer> *>(deleterData);
+      };
+      *deleterData = new std::shared_ptr<const facebook::jsi::Buffer>(std::move(preparedScript));
+    } else {
+      *buffer = nullptr;
+      *bufferSize = 0;
+      *bufferDeleteCallback = nullptr;
+      *deleterData = nullptr;
+    }
+  }
+
+  static void NAPI_CDECL StoreScript(
+      void *scriptCache,
+      const char *sourceUrl,
+      uint64_t sourceHash,
+      const char *runtimeName,
+      uint64_t runtimeVersion,
+      const char *cacheTag,
+      const uint8_t *buffer,
+      size_t bufferSize,
+      jsr_data_delete_cb bufferDeleteCallback,
+      void *deleterData) {
+    auto &scriptStore = reinterpret_cast<HermesScriptCache *>(scriptCache)->scriptStore_;
+    scriptStore->persistPreparedScript(
+        HermesJsiBuffer::Create(buffer, bufferSize, bufferDeleteCallback, deleterData),
+        facebook::jsi::ScriptSignature{sourceUrl, sourceHash},
+        facebook::jsi::JSRuntimeSignature{runtimeName, runtimeVersion},
+        cacheTag);
+  }
+
+  static void NAPI_CDECL Delete(void *scriptCache, void * /*deleterData*/) {
+    delete reinterpret_cast<HermesScriptCache *>(scriptCache);
+  }
+
+ private:
+  std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore_;
+};
+
+class HermesLocalConnection : public facebook::react::ILocalConnection {
+ public:
+  HermesLocalConnection(
+      std::unique_ptr<facebook::react::IRemoteConnection> remoteConneciton,
+      void *connectFunc) noexcept {
+    CRASH_ON_ERROR(getHermesApi().hermes_create_local_connection(
+        connectFunc,
+        reinterpret_cast<hermes_remote_connection>(remoteConneciton.release()),
+        &OnRemoteConnectionSendMessage,
+        &OnRemoteConnectionDisconnect,
+        &OnRemoteConnectionDelete,
+        nullptr,
+        &localConnection_));
+  }
 
-  jsi::Runtime &getRuntime() override {
-    return *m_runtime;
+  ~HermesLocalConnection() override {
+    CRASH_ON_ERROR(getHermesApi().hermes_delete_local_connection(localConnection_));
   }
 
-  facebook::hermes::debugger::Debugger &getDebugger() override {
-    return m_hermesRuntime.getDebugger();
+  void sendMessage(std::string message) {
+    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_send_message(localConnection_, message.c_str()));
   }
 
-  void tickleJs() override {
-    // The queue will ensure that runtime_ is still valid when this
-    // gets invoked.
-    m_thread->runOnQueue([&runtime = m_runtime]() {
-      auto func = runtime->global().getPropertyAsFunction(*runtime, "__tickleJs");
-      func.call(*runtime);
-    });
+  void disconnect() {
+    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_disconnect(localConnection_));
   }
 
  private:
-  std::shared_ptr<jsi::Runtime> m_runtime;
-  facebook::hermes::HermesRuntime &m_hermesRuntime;
+  static void NAPI_CDECL OnRemoteConnectionSendMessage(hermes_remote_connection remoteConnection, const char *message) {
+    reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection)->onMessage(message);
+  }
+
+  static void NAPI_CDECL OnRemoteConnectionDisconnect(hermes_remote_connection remoteConnection) {
+    reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection)->onDisconnect();
+  }
 
-  std::shared_ptr<MessageQueueThread> m_thread;
+  static void NAPI_CDECL OnRemoteConnectionDelete(void *remoteConnection, void * /*deleterData*/) {
+    delete reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection);
+  }
+
+ private:
+  hermes_local_connection localConnection_{};
 };
-#endif
+
+int32_t NAPI_CDECL addInspectorPage(const char *title, const char *vm, void *connectFunc) noexcept {
+  return facebook::react::getInspectorInstance().addPage(
+      title,
+      vm,
+      [connectFunc,
+       hermesApi = HermesApi::current()](std::unique_ptr<facebook::react::IRemoteConnection> remoteConneciton) {
+        HermesApi::Scope apiScope(hermesApi);
+        return std::make_unique<HermesLocalConnection>(std::move(remoteConneciton), connectFunc);
+      });
+}
+
+void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept {
+  facebook::react::getInspectorInstance().removePage(pageId);
+}
 
 } // namespace
 
-void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  HermesShim::hermesCrashHandler(*m_hermesRuntime, fileDescriptor);
+HermesRuntimeHolder::HermesRuntimeHolder(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
+    std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore) noexcept
+    : m_weakDevSettings(devSettings),
+      m_jsQueue(std::move(jsQueue)),
+      m_preparedScriptStore(std::move(preparedScriptStore)) {}
+
+HermesRuntimeHolder::~HermesRuntimeHolder() {
+  if (m_runtime) {
+    CRASH_ON_ERROR(getHermesApi().jsr_delete_runtime(m_runtime));
+  }
 }
 
-void HermesRuntimeHolder::teardown() noexcept {
-#ifdef HERMES_ENABLE_DEBUGGER
-  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
-    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
+void HermesRuntimeHolder::initRuntime() noexcept {
+  facebook::react::SystraceSection s("HermesExecutorFactory::makeHermesRuntimeSystraced");
+  std::shared_ptr<facebook::react::DevSettings> devSettings = m_weakDevSettings.lock();
+  VerifyElseCrash(devSettings);
+
+  HermesApi &api = getHermesApi();
+  HermesApi::setCurrent(&api);
+  jsr_config config{};
+  CRASH_ON_ERROR(api.jsr_create_config(&config));
+  CRASH_ON_ERROR(api.hermes_config_enable_default_crash_handler(config, devSettings->enableDefaultCrashHandler));
+  CRASH_ON_ERROR(api.jsr_config_enable_inspector(config, devSettings->useDirectDebugger));
+  CRASH_ON_ERROR(api.jsr_config_set_inspector_runtime_name(config, devSettings->debuggerRuntimeName.c_str()));
+  CRASH_ON_ERROR(api.jsr_config_set_inspector_port(config, devSettings->debuggerPort));
+  CRASH_ON_ERROR(api.jsr_config_set_inspector_break_on_start(config, devSettings->debuggerBreakOnNextLine));
+  if (m_jsQueue) {
+    HermesTaskRunner::Create(config, m_jsQueue);
+  }
+  if (m_preparedScriptStore) {
+    HermesScriptCache::Create(config, m_preparedScriptStore);
   }
-#endif
+  jsr_runtime runtime{};
+  CRASH_ON_ERROR(api.jsr_create_runtime(config, &runtime));
+  CRASH_ON_ERROR(api.jsr_delete_config(config));
+
+  napi_env env{};
+  CRASH_ON_ERROR(api.jsr_runtime_get_node_api_env(runtime, &env));
+
+  m_jsiRuntime = makeNodeApiJsiRuntime(
+      env, &api, [runtime]() { CRASH_ON_ERROR(HermesApi::current()->jsr_delete_runtime(runtime)); });
+  m_ownThreadId = std::this_thread::get_id();
+
+  // Add JS engine information to Error.prototype so in error reporting we
+  // can send this information.
+  auto errorPrototype = m_jsiRuntime->global()
+                            .getPropertyAsObject(*m_jsiRuntime, "Error")
+                            .getPropertyAsObject(*m_jsiRuntime, "prototype");
+  errorPrototype.setProperty(*m_jsiRuntime, "jsEngine", "hermes");
 }
 
 facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
   return facebook::react::JSIEngineOverride::Hermes;
 }
 
-std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
-  std::call_once(m_once_flag, [this]() { initRuntime(); });
+std::shared_ptr<facebook::jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
+  std::call_once(m_onceFlag, [this]() { initRuntime(); });
+  VerifyElseCrash(m_jsiRuntime);
+  return m_jsiRuntime;
+}
+
+void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_dump_crash_data(m_runtime, fileDescriptor));
+}
 
-  if (!m_hermesRuntime)
-    std::terminate();
+void HermesRuntimeHolder::teardown() noexcept {
+  // TODO: (vmoroz) Implement
+}
 
-  // Make sure that the runtime instance is not consumed from multiple threads.
-  if (m_own_thread_id != std::this_thread::get_id())
-    std::terminate();
+std::shared_ptr<HermesRuntimeHolder> HermesRuntimeHolder::loadFrom(
+    React::ReactPropertyBag const &propertyBag) noexcept {
+  return *(propertyBag.Get(HermesRuntimeHolderProperty()));
+}
 
-  return m_hermesRuntime;
+void HermesRuntimeHolder::storeTo(
+    React::ReactPropertyBag const &propertyBag,
+    std::shared_ptr<HermesRuntimeHolder> const &holder) noexcept {
+  propertyBag.Set(HermesRuntimeHolderProperty(), holder);
 }
 
-HermesRuntimeHolder::HermesRuntimeHolder(
-    std::shared_ptr<facebook::react::DevSettings> devSettings,
-    std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept
-    : m_weakDevSettings(devSettings), m_jsQueue(std::move(jsQueue)) {}
+void HermesRuntimeHolder::addToProfiling() const noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_add(m_runtime));
+}
 
-void HermesRuntimeHolder::initRuntime() noexcept {
-  auto devSettings = m_weakDevSettings.lock();
-  if (!devSettings)
-    std::terminate();
+void HermesRuntimeHolder::removeFromProfiling() const noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_remove(m_runtime));
+}
 
-  m_hermesRuntime = makeHermesRuntimeSystraced(devSettings->enableDefaultCrashHandler);
-  m_own_thread_id = std::this_thread::get_id();
+/*static*/ void HermesRuntimeHolder::enableSamplingProfiler() noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_enable());
+}
 
-#ifdef HERMES_ENABLE_DEBUGGER
-  if (devSettings->useDirectDebugger) {
-    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_hermesRuntime, *m_hermesRuntime, m_jsQueue);
-    facebook::hermes::inspector::chrome::enableDebugging(
-        std::move(adapter),
-        devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : devSettings->debuggerRuntimeName);
-  }
-#endif
+/*static*/ void HermesRuntimeHolder::disableSamplingProfiler() noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_disable());
+}
 
-  // Add js engine information to Error.prototype so in error reporting we
-  // can send this information.
-  auto errorPrototype = m_hermesRuntime->global()
-                            .getPropertyAsObject(*m_hermesRuntime, "Error")
-                            .getPropertyAsObject(*m_hermesRuntime, "prototype");
-  errorPrototype.setProperty(*m_hermesRuntime, "jsEngine", "hermes");
+/*static*/ void HermesRuntimeHolder::dumpSampledTraceToFile(const std::string &fileName) noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_dump_to_file(fileName.c_str()));
 }
 
-} // namespace react
-} // namespace facebook
+} // namespace Microsoft::ReactNative

package/Shared/HermesRuntimeHolder.h

@@ -2,43 +2,54 @@
 // Licensed under the MIT License.
 
 #pragma once
-#include <JSI/RuntimeHolder.h>
-
-#include <jsi/jsi.h>
-#include <thread>
-
 #include <DevSettings.h>
+#include <JSI/RuntimeHolder.h>
+#include <JSI/ScriptStore.h>
+#include <ReactPropertyBag.h>
+#include <cxxreact/MessageQueueThread.h>
+#include <hermes/hermes_api.h>
 
-namespace facebook::hermes {
-class HermesRuntime;
-}
-
-namespace facebook {
-namespace react {
+namespace Microsoft::ReactNative {
 
 class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
- public:
+ public: // RuntimeHolderLazyInit implementation.
   std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
   facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
-
   void crashHandler(int fileDescriptor) noexcept override;
-
   void teardown() noexcept override;
 
+ public:
   HermesRuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,
-      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept;
+      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
+      std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore) noexcept;
+  ~HermesRuntimeHolder();
+
+  static std::shared_ptr<HermesRuntimeHolder> loadFrom(
+      winrt::Microsoft::ReactNative::ReactPropertyBag const &propertyBag) noexcept;
+
+  static void storeTo(
+      winrt::Microsoft::ReactNative::ReactPropertyBag const &propertyBag,
+      std::shared_ptr<HermesRuntimeHolder> const &holder) noexcept;
+
+  void addToProfiling() const noexcept;
+  void removeFromProfiling() const noexcept;
+
+  static void enableSamplingProfiler() noexcept;
+  static void disableSamplingProfiler() noexcept;
+  static void dumpSampledTraceToFile(const std::string &fileName) noexcept;
 
  private:
   void initRuntime() noexcept;
-  std::shared_ptr<facebook::hermes::HermesRuntime> m_hermesRuntime;
-
-  std::once_flag m_once_flag;
-  std::thread::id m_own_thread_id;
 
+ private:
+  jsr_runtime m_runtime{};
+  std::shared_ptr<facebook::jsi::Runtime> m_jsiRuntime;
+  std::once_flag m_onceFlag{};
+  std::thread::id m_ownThreadId{};
   std::weak_ptr<facebook::react::DevSettings> m_weakDevSettings;
   std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
+  std::shared_ptr<facebook::jsi::PreparedScriptStore> m_preparedScriptStore;
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace Microsoft::ReactNative

package/Shared/HermesSamplingProfiler.cpp

@@ -3,19 +3,51 @@
 
 #include "pch.h"
 
-#include <hermes/hermes.h>
+#include <hermes/hermes_api.h>
 #include <chrono>
 #include <future>
 
+#include "HermesRuntimeHolder.h"
 #include "HermesSamplingProfiler.h"
-#include "HermesShim.h"
+#include "IReactDispatcher.h"
+#include "ReactPropertyBag.h"
 #include "Utils.h"
 
+using namespace winrt::Microsoft::ReactNative;
+using namespace facebook::react;
+
 namespace Microsoft::ReactNative {
 
 namespace {
+
+// Implements an awaiter for Mso::DispatchQueue
+auto resume_in_dispatcher(const IReactDispatcher &dispatcher) noexcept {
+  struct awaitable {
+    awaitable(const IReactDispatcher &dispatcher) noexcept : dispatcher_(dispatcher) {}
+
+    bool await_ready() const noexcept {
+      return false;
+    }
+
+    void await_resume() const noexcept {}
+
+    void await_suspend(std::experimental::coroutine_handle<> resume) noexcept {
+      callback_ = [context = resume.address()]() noexcept {
+        std::experimental::coroutine_handle<>::from_address(context)();
+      };
+      dispatcher_.Post(std::move(callback_));
+    }
+
+   private:
+    IReactDispatcher dispatcher_;
+    ReactDispatcherCallback callback_;
+  };
+
+  return awaitable{dispatcher};
+}
+
 std::future<std::string> getTraceFilePath() noexcept {
-  auto hermesDataPath = co_await Microsoft::React::getApplicationDataPath(L"Hermes");
+  std::string hermesDataPath = co_await Microsoft::React::getApplicationDataPath(L"Hermes");
   std::ostringstream os;
   auto now = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch())
                  .count();
@@ -23,39 +55,59 @@ std::future<std::string> getTraceFilePath() noexcept {
   os << hermesDataPath << "\\cpu_" << now << ".cpuprofile";
   co_return os.str();
 }
+
 } // namespace
 
-bool HermesSamplingProfiler::s_isStarted = false;
+std::atomic_bool HermesSamplingProfiler::s_isStarted{false};
 std::string HermesSamplingProfiler::s_lastTraceFilePath;
 
 std::string HermesSamplingProfiler::GetLastTraceFilePath() noexcept {
   return s_lastTraceFilePath;
 }
 
-winrt::fire_and_forget HermesSamplingProfiler::Start() noexcept {
-  if (!s_isStarted) {
-    s_isStarted = true;
+winrt::fire_and_forget HermesSamplingProfiler::Start(
+    Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
+  bool expectedIsStarted = false;
+  if (s_isStarted.compare_exchange_strong(expectedIsStarted, true)) {
+    IReactDispatcher jsDispatcher = implementation::ReactDispatcher::GetJSDispatcher(reactContext->Properties());
+    ReactPropertyBag propertyBag = ReactPropertyBag(reactContext->Properties());
+
+    co_await resume_in_dispatcher(jsDispatcher);
+    std::shared_ptr<HermesRuntimeHolder> hermesRuntimeHolder = HermesRuntimeHolder::loadFrom(propertyBag);
+    hermesRuntimeHolder->addToProfiling();
+
     co_await winrt::resume_background();
-    HermesShim::enableSamplingProfiler();
+    HermesRuntimeHolder::enableSamplingProfiler();
   }
 
   co_return;
 }
 
-std::future<std::string> HermesSamplingProfiler::Stop() noexcept {
-  if (s_isStarted) {
-    s_isStarted = false;
+std::future<std::string> HermesSamplingProfiler::Stop(
+    Mso::CntPtr<Mso::React::IReactContext> const &reactContext) noexcept {
+  bool expectedIsStarted = true;
+  if (s_isStarted.compare_exchange_strong(expectedIsStarted, false)) {
+    IReactDispatcher jsDispatcher = implementation::ReactDispatcher::GetJSDispatcher(reactContext->Properties());
+    ReactPropertyBag propertyBag = ReactPropertyBag(reactContext->Properties());
+
     co_await winrt::resume_background();
-    HermesShim::disableSamplingProfiler();
+    HermesRuntimeHolder::disableSamplingProfiler();
+
     s_lastTraceFilePath = co_await getTraceFilePath();
-    HermesShim::dumpSampledTraceToFile(s_lastTraceFilePath);
+    HermesRuntimeHolder::dumpSampledTraceToFile(s_lastTraceFilePath);
+
+    co_await resume_in_dispatcher(jsDispatcher);
+    std::shared_ptr<HermesRuntimeHolder> hermesRuntimeHolder = HermesRuntimeHolder::loadFrom(propertyBag);
+    hermesRuntimeHolder->removeFromProfiling();
+
+    co_await winrt::resume_background();
   }
 
   co_return s_lastTraceFilePath;
 }
 
 bool HermesSamplingProfiler::IsStarted() noexcept {
-  return s_isStarted;
+  return s_isStarted.load();
 }
 
 } // namespace Microsoft::ReactNative