react-native-windows 0.71.26 → 0.71.28

package/Shared/HermesRuntimeHolder.cpp

@@ -3,394 +3,134 @@
 
 #include "pch.h"
 
-#include "HermesRuntimeHolder.h"
+#include <memory>
+#include <mutex>
 
-#include <ApiLoaders/HermesApi.h>
 #include <JSI/decorator.h>
-#include <NodeApiJsiRuntime.h>
-#include <crash/verifyElseCrash.h>
+#include <cxxreact/MessageQueueThread.h>
 #include <cxxreact/SystraceSection.h>
-#include <jsinspector/InspectorInterfaces.h>
-#include <mutex>
-#include "SafeLoadLibrary.h"
-
-#define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
+#include <hermes/hermes.h>
+#include "HermesRuntimeHolder.h"
+#include "HermesShim.h"
 
-namespace React {
-using namespace winrt::Microsoft::ReactNative;
-}
+#if defined(HERMES_ENABLE_DEBUGGER)
+#include <hermes/inspector/chrome/Registration.h>
+#endif
 
-using namespace Microsoft::NodeApiJsi;
+using namespace facebook;
+using namespace Microsoft::ReactNative;
 
-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 facebook {
+namespace react {
 
 namespace {
 
-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));
+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);
   }
-
- 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;
 }
 
-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 {
+#ifdef HERMES_ENABLE_DEBUGGER
+class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::RuntimeAdapter {
  public:
-  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));
-  }
+  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)) {}
 
- 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_));
-  }
+  virtual ~HermesExecutorRuntimeAdapter() = default;
 
-  ~HermesLocalConnection() override {
-    CRASH_ON_ERROR(getHermesApi().hermes_delete_local_connection(localConnection_));
+  jsi::Runtime &getRuntime() override {
+    return *m_runtime;
   }
 
-  void sendMessage(std::string message) {
-    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_send_message(localConnection_, message.c_str()));
+  facebook::hermes::debugger::Debugger &getDebugger() override {
+    return m_hermesRuntime.getDebugger();
   }
 
-  void disconnect() {
-    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_disconnect(localConnection_));
+  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);
+    });
   }
 
  private:
-  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<jsi::Runtime> m_runtime;
+  facebook::hermes::HermesRuntime &m_hermesRuntime;
 
-  static void NAPI_CDECL OnRemoteConnectionDelete(void *remoteConnection, void * /*deleterData*/) {
-    delete reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection);
-  }
-
- private:
-  hermes_local_connection localConnection_{};
+  std::shared_ptr<MessageQueueThread> m_thread;
 };
-
-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);
-}
+#endif
 
 } // namespace
 
-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::crashHandler(int fileDescriptor) noexcept {
+  HermesShim::hermesCrashHandler(*m_hermesRuntime, fileDescriptor);
 }
 
-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);
+void HermesRuntimeHolder::teardown() noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
+  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
+    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
   }
-  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");
+#endif
 }
 
 facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
   return facebook::react::JSIEngineOverride::Hermes;
 }
 
-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));
-}
+std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
+  std::call_once(m_once_flag, [this]() { initRuntime(); });
 
-void HermesRuntimeHolder::teardown() noexcept {
-  // TODO: (vmoroz) Implement
-}
+  if (!m_hermesRuntime)
+    std::terminate();
 
-std::shared_ptr<HermesRuntimeHolder> HermesRuntimeHolder::loadFrom(
-    React::ReactPropertyBag const &propertyBag) noexcept {
-  return *(propertyBag.Get(HermesRuntimeHolderProperty()));
-}
+  // Make sure that the runtime instance is not consumed from multiple threads.
+  if (m_own_thread_id != std::this_thread::get_id())
+    std::terminate();
 
-void HermesRuntimeHolder::storeTo(
-    React::ReactPropertyBag const &propertyBag,
-    std::shared_ptr<HermesRuntimeHolder> const &holder) noexcept {
-  propertyBag.Set(HermesRuntimeHolderProperty(), holder);
+  return m_hermesRuntime;
 }
 
-void HermesRuntimeHolder::addToProfiling() const noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_add(m_runtime));
-}
+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::removeFromProfiling() const noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_remove(m_runtime));
-}
+void HermesRuntimeHolder::initRuntime() noexcept {
+  auto devSettings = m_weakDevSettings.lock();
+  if (!devSettings)
+    std::terminate();
 
-/*static*/ void HermesRuntimeHolder::enableSamplingProfiler() noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_enable());
-}
+  m_hermesRuntime = makeHermesRuntimeSystraced(devSettings->enableDefaultCrashHandler);
+  m_own_thread_id = std::this_thread::get_id();
 
-/*static*/ void HermesRuntimeHolder::disableSamplingProfiler() noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_disable());
-}
+#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::dumpSampledTraceToFile(const std::string &fileName) noexcept {
-  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_dump_to_file(fileName.c_str()));
+  // 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");
 }
 
-} // namespace Microsoft::ReactNative
+} // namespace react
+} // namespace facebook

package/Shared/HermesRuntimeHolder.h

@@ -2,54 +2,43 @@
 // Licensed under the MIT License.
 
 #pragma once
-#include <DevSettings.h>
 #include <JSI/RuntimeHolder.h>
-#include <JSI/ScriptStore.h>
-#include <ReactPropertyBag.h>
-#include <cxxreact/MessageQueueThread.h>
-#include <hermes/hermes_api.h>
 
-namespace Microsoft::ReactNative {
+#include <jsi/jsi.h>
+#include <thread>
+
+#include <DevSettings.h>
+
+namespace facebook::hermes {
+class HermesRuntime;
+}
+
+namespace facebook {
+namespace react {
 
 class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
- public: // RuntimeHolderLazyInit implementation.
+ public:
   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,
-      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;
+      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) 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 Microsoft::ReactNative
+} // namespace react
+} // namespace facebook

package/Shared/HermesSamplingProfiler.cpp

@@ -3,51 +3,19 @@
 
 #include "pch.h"
 
-#include <hermes/hermes_api.h>
+#include <hermes/hermes.h>
 #include <chrono>
 #include <future>
 
-#include "HermesRuntimeHolder.h"
 #include "HermesSamplingProfiler.h"
-#include "IReactDispatcher.h"
-#include "ReactPropertyBag.h"
+#include "HermesShim.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 {
-  std::string hermesDataPath = co_await Microsoft::React::getApplicationDataPath(L"Hermes");
+  auto 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();
@@ -55,59 +23,39 @@ std::future<std::string> getTraceFilePath() noexcept {
   os << hermesDataPath << "\\cpu_" << now << ".cpuprofile";
   co_return os.str();
 }
-
 } // namespace
 
-std::atomic_bool HermesSamplingProfiler::s_isStarted{false};
+bool HermesSamplingProfiler::s_isStarted = false;
 std::string HermesSamplingProfiler::s_lastTraceFilePath;
 
 std::string HermesSamplingProfiler::GetLastTraceFilePath() noexcept {
   return s_lastTraceFilePath;
 }
 
-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();
-
+winrt::fire_and_forget HermesSamplingProfiler::Start() noexcept {
+  if (!s_isStarted) {
+    s_isStarted = true;
     co_await winrt::resume_background();
-    HermesRuntimeHolder::enableSamplingProfiler();
+    HermesShim::enableSamplingProfiler();
   }
 
   co_return;
 }
 
-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());
-
+std::future<std::string> HermesSamplingProfiler::Stop() noexcept {
+  if (s_isStarted) {
+    s_isStarted = false;
     co_await winrt::resume_background();
-    HermesRuntimeHolder::disableSamplingProfiler();
-
+    HermesShim::disableSamplingProfiler();
     s_lastTraceFilePath = co_await getTraceFilePath();
-    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();
+    HermesShim::dumpSampledTraceToFile(s_lastTraceFilePath);
   }
 
   co_return s_lastTraceFilePath;
 }
 
 bool HermesSamplingProfiler::IsStarted() noexcept {
-  return s_isStarted.load();
+  return s_isStarted;
 }
 
 } // namespace Microsoft::ReactNative