react-native-windows 0.72.0-preview.7 → 0.72.0-preview.9

package/Shared/HermesRuntimeHolder.cpp

@@ -5,28 +5,24 @@
 
 #include "HermesRuntimeHolder.h"
 
+#include <ApiLoaders/HermesApi.h>
 #include <JSI/decorator.h>
+#include <NodeApiJsiRuntime.h>
 #include <crash/verifyElseCrash.h>
-#include <cxxreact/MessageQueueThread.h>
 #include <cxxreact/SystraceSection.h>
-#include <hermes/hermes.h>
-#include "HermesShim.h"
-
-#if defined(HERMES_ENABLE_DEBUGGER)
-#include <hermes/inspector/chrome/Registration.h>
-#endif
-
-#include <memory>
+#include <jsinspector/InspectorInterfaces.h>
 #include <mutex>
+#include "SafeLoadLibrary.h"
 
-using namespace facebook;
-using namespace Microsoft::ReactNative;
+#define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
 
 namespace React {
 using namespace winrt::Microsoft::ReactNative;
 }
 
-namespace facebook::react {
+using namespace Microsoft::NodeApiJsi;
+
+namespace Microsoft::ReactNative {
 
 React::ReactPropertyId<React::ReactNonAbiValue<std::shared_ptr<HermesRuntimeHolder>>>
 HermesRuntimeHolderProperty() noexcept {
@@ -37,104 +33,333 @@ HermesRuntimeHolderProperty() noexcept {
 
 namespace {
 
-#ifdef HERMES_ENABLE_DEBUGGER
-class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::RuntimeAdapter {
+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:
-  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)) {}
+  HermesFuncResolver() : libHandle_(SafeLoadLibrary(L"hermes.dll")) {}
+
+  FuncPtr getFuncPtr(const char *funcName) override {
+    return reinterpret_cast<FuncPtr>(GetProcAddress(libHandle_, funcName));
+  }
 
-  virtual ~HermesExecutorRuntimeAdapter() = default;
+ 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;
+}
 
-  jsi::Runtime &getRuntime() override {
-    return *m_runtime;
+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_);
+    }
   }
 
-  facebook::hermes::debugger::Debugger &getDebugger() override {
-    return m_hermesRuntime.getDebugger();
+  void Run() const {
+    if (taskRunCallback_ != nullptr) {
+      taskRunCallback_(taskData_);
+    }
   }
 
-  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:
+  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:
-  std::shared_ptr<jsi::Runtime> m_runtime;
-  facebook::hermes::HermesRuntime &m_hermesRuntime;
+  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(); });
+  }
 
-  std::shared_ptr<MessageQueueThread> m_thread;
+  static void NAPI_CDECL Delete(void *taskRunner, void * /*deleterData*/) {
+    delete reinterpret_cast<HermesTaskRunner *>(taskRunner);
+  }
+
+ private:
+  std::shared_ptr<facebook::react::MessageQueueThread> queue_;
 };
-#endif
 
-std::shared_ptr<HermesShim> makeHermesShimSystraced(bool enableDefaultCrashHandler) {
-  SystraceSection s("HermesExecutorFactory::makeHermesRuntimeSystraced");
-  if (enableDefaultCrashHandler) {
-    return HermesShim::makeWithWER();
-  } else {
-    return HermesShim::make();
+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));
   }
-}
 
-} // namespace
+  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_);
+    }
+  }
 
-void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  m_hermesShim->dumpCrashData(fileDescriptor);
-}
+  const uint8_t *data() const override {
+    return buffer_;
+  }
 
-void HermesRuntimeHolder::teardown() noexcept {
-#ifdef HERMES_ENABLE_DEBUGGER
-  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
-    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
+  size_t size() const override {
+    return bufferSize_;
   }
-#endif
-}
 
-facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
-  return facebook::react::JSIEngineOverride::Hermes;
+ private:
+  const uint8_t *buffer_;
+  size_t bufferSize_;
+  jsr_data_delete_cb bufferDeleteCallback_;
+  void *deleterData_;
+};
+
+class HermesScriptCache {
+ 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));
+  }
+
+ 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_));
+  }
+
+  ~HermesLocalConnection() override {
+    CRASH_ON_ERROR(getHermesApi().hermes_delete_local_connection(localConnection_));
+  }
+
+  void sendMessage(std::string message) {
+    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_send_message(localConnection_, message.c_str()));
+  }
+
+  void disconnect() {
+    CRASH_ON_ERROR(getHermesApi().hermes_local_connection_disconnect(localConnection_));
+  }
+
+ 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();
+  }
+
+  static void NAPI_CDECL OnRemoteConnectionDelete(void *remoteConnection, void * /*deleterData*/) {
+    delete reinterpret_cast<facebook::react::IRemoteConnection *>(remoteConnection);
+  }
+
+ private:
+  hermes_local_connection localConnection_{};
+};
+
+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);
+      });
 }
 
-std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
-  std::call_once(m_onceFlag, [this]() { initRuntime(); });
-  VerifyElseCrash(m_hermesRuntime);
-  VerifyElseCrashSz(m_ownThreadId == std::this_thread::get_id(), "Must be accessed from JS thread.");
-  return m_hermesRuntime;
+void NAPI_CDECL removeInspectorPage(int32_t pageId) noexcept {
+  facebook::react::getInspectorInstance().removePage(pageId);
 }
 
+} // namespace
+
 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)) {}
+    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::initRuntime() noexcept {
-  auto devSettings = m_weakDevSettings.lock();
+  facebook::react::SystraceSection s("HermesExecutorFactory::makeHermesRuntimeSystraced");
+  std::shared_ptr<facebook::react::DevSettings> devSettings = m_weakDevSettings.lock();
   VerifyElseCrash(devSettings);
 
-  m_hermesShim = makeHermesShimSystraced(devSettings->enableDefaultCrashHandler);
-  m_hermesRuntime = m_hermesShim->getRuntime();
-  m_ownThreadId = std::this_thread::get_id();
-
-#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);
+  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));
 
-  // Add js engine information to Error.prototype so in error reporting we
+  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_hermesRuntime->global()
-                            .getPropertyAsObject(*m_hermesRuntime, "Error")
-                            .getPropertyAsObject(*m_hermesRuntime, "prototype");
-  errorPrototype.setProperty(*m_hermesRuntime, "jsEngine", "hermes");
+  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<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));
+}
+
+void HermesRuntimeHolder::teardown() noexcept {
+  // TODO: (vmoroz) Implement
 }
 
 std::shared_ptr<HermesRuntimeHolder> HermesRuntimeHolder::loadFrom(
@@ -149,11 +374,23 @@ void HermesRuntimeHolder::storeTo(
 }
 
 void HermesRuntimeHolder::addToProfiling() const noexcept {
-  m_hermesShim->addToProfiling();
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_add(m_runtime));
 }
 
 void HermesRuntimeHolder::removeFromProfiling() const noexcept {
-  m_hermesShim->removeFromProfiling();
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_remove(m_runtime));
+}
+
+/*static*/ void HermesRuntimeHolder::enableSamplingProfiler() noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_enable());
+}
+
+/*static*/ void HermesRuntimeHolder::disableSamplingProfiler() noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_disable());
+}
+
+/*static*/ void HermesRuntimeHolder::dumpSampledTraceToFile(const std::string &fileName) noexcept {
+  CRASH_ON_ERROR(getHermesApi().hermes_sampling_profiler_dump_to_file(fileName.c_str()));
 }
 
-} // namespace facebook::react
+} // namespace Microsoft::ReactNative

package/Shared/HermesRuntimeHolder.h

@@ -2,25 +2,14 @@
 // 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>
-
-namespace facebook::hermes {
-class HermesRuntime;
-}
+#include <cxxreact/MessageQueueThread.h>
+#include <hermes/hermes_api.h>
 
 namespace Microsoft::ReactNative {
-class HermesShim;
-}
-
-namespace facebook::react {
-
-class MessageQueueThread;
 
 class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
  public: // RuntimeHolderLazyInit implementation.
@@ -32,7 +21,9 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
  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;
@@ -44,16 +35,21 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
   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;
 
  private:
-  std::shared_ptr<Microsoft::ReactNative::HermesShim> m_hermesShim;
-  std::shared_ptr<facebook::hermes::HermesRuntime> m_hermesRuntime;
+  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 facebook::react
+} // namespace Microsoft::ReactNative

package/Shared/HermesSamplingProfiler.cpp

@@ -3,13 +3,12 @@
 
 #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"
@@ -48,7 +47,7 @@ auto resume_in_dispatcher(const IReactDispatcher &dispatcher) noexcept {
 }
 
 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();
@@ -78,7 +77,7 @@ winrt::fire_and_forget HermesSamplingProfiler::Start(
     hermesRuntimeHolder->addToProfiling();
 
     co_await winrt::resume_background();
-    HermesShim::enableSamplingProfiler();
+    HermesRuntimeHolder::enableSamplingProfiler();
   }
 
   co_return;
@@ -92,10 +91,10 @@ std::future<std::string> HermesSamplingProfiler::Stop(
     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);