react-native-windows 0.0.0-canary.95 → 0.0.0-canary.950

package/Shared/JSI/ScriptStore.h

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+#pragma once
+
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace facebook::jsi {
+
+// Integer type as it's persist friendly.
+using ScriptVersion_t = uint64_t; // It should be std::optional<uint64_t> once we have c++17 available everywhere.
+                                  // Until then, 0 implies versioning not available.
+using JSRuntimeVersion_t = uint64_t; // 0 implies version can't be computed. We assert whenever that happens.
+
+struct VersionedBuffer {
+  std::shared_ptr<const facebook::jsi::Buffer> buffer;
+  ScriptVersion_t version;
+};
+
+struct ScriptSignature {
+  std::string url;
+  ScriptVersion_t version;
+};
+
+struct JSRuntimeSignature {
+  std::string runtimeName; // e.g. Chakra, V8
+  JSRuntimeVersion_t version;
+};
+
+// Most JSI::Runtime implementation offer some form of prepared JavaScript which offers better performance
+// characteristics when loading comparing to plain JavaScript. Embedders can provide an instance of this interface
+// (through JSI::Runtime implementation's factory method), to enable persistence of the prepared script
+// and retrieval on subsequent evaluation of a script.
+struct PreparedScriptStore {
+  virtual ~PreparedScriptStore() = default;
+
+  // Try to retrieve the prepared JavaScript for a given combination of script & runtime.
+  // scriptSignature : JavaScript URL and version
+  // RuntimeSignature : JavaScript engine type and version
+  // prepareTag : Custom tag to uniquely identify JS engine specific preparation schemes. It is usually useful while
+  // experimentation and can be null. It is possible that no prepared script is available for a given script & runtime
+  // signature. This method should null if so
+  virtual std::shared_ptr<const facebook::jsi::Buffer> tryGetPreparedScript(
+      const ScriptSignature &scriptSignature,
+      const JSRuntimeSignature &runtimeSignature,
+      const char *prepareTag // Optional tag. For e.g. eagerly evaluated vs lazy cache.
+      ) noexcept = 0;
+
+  // Persist the prepared JavaScript for a given combination of script & runtime.
+  // scriptSignature : JavaScript URL and version
+  // RuntimeSignature : JavaScript engine type and version
+  // prepareTag : Custom tag to uniquely identify JS engine specific preparation schemes. It is usually useful while
+  // experimentation and can be null. It is possible that no prepared script is available for a given script & runtime
+  // signature. This method should null if so Any failure in persistence should be identified during the subsequent
+  // retrieval through the integrity mechanism which must be put into the storage.
+  virtual void persistPreparedScript(
+      std::shared_ptr<const facebook::jsi::Buffer> preparedScript,
+      const ScriptSignature &scriptMetadata,
+      const JSRuntimeSignature &runtimeMetadata,
+      const char *prepareTag // Optional tag. For e.g. eagerly evaluated vs lazy cache.
+      ) noexcept = 0;
+};
+
+// JSI::Runtime implementation must be provided an instance on this interface to enable version sensitive capabilities
+// such as usage of prepared JavaScript script. Alternatively, this entity can be used to directly provide the
+// JavaScript buffer and rich meta data to the JSI::Runtime instance.
+struct ScriptStore {
+  virtual ~ScriptStore() = default;
+
+  // Return the JavaScript buffer and version corresponding to a given URL.
+  virtual VersionedBuffer getVersionedScript(const std::string &url) noexcept = 0;
+
+  // Return the version of the JavaScript buffer corresponding to a given URL.
+  virtual ScriptVersion_t getScriptVersion(const std::string &url) noexcept = 0;
+};
+
+} // namespace facebook::jsi

package/Shared/JSI/V8RuntimeHolder.cpp

@@ -0,0 +1,260 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "V8RuntimeHolder.h"
+#include <ApiLoaders/V8Api.h>
+#include <NodeApiJsiRuntime.h>
+#include <crash/verifyElseCrash.h>
+#include "SafeLoadLibrary.h"
+
+using namespace Microsoft::NodeApiJsi;
+
+#define CRASH_ON_ERROR(result) VerifyElseCrash(result == napi_ok);
+
+namespace Microsoft::ReactNative {
+namespace {
+
+class V8FuncResolver : public IFuncResolver {
+ public:
+  V8FuncResolver() : libHandle_(LoadLibraryAsPeerFirst(L"v8jsi.dll")) {}
+
+  FuncPtr getFuncPtr(const char *funcName) override {
+    return reinterpret_cast<FuncPtr>(GetProcAddress(libHandle_, funcName));
+  }
+
+ private:
+  HMODULE libHandle_;
+};
+
+V8Api &initV8Api() noexcept {
+  static V8FuncResolver funcResolver;
+  static V8Api s_v8Api(&funcResolver);
+  V8Api::setCurrent(&s_v8Api);
+  return s_v8Api;
+}
+
+V8Api &getV8Api() noexcept {
+  static V8Api &s_v8Api = initV8Api();
+  return s_v8Api;
+}
+
+class V8Task {
+ public:
+  V8Task(void *taskData, jsr_task_run_cb taskRunCallback, jsr_data_delete_cb taskDataDeleteCallback, void *deleterData)
+      : taskData_(taskData),
+        taskRunCallback_(taskRunCallback),
+        taskDataDeleteCallback_(taskDataDeleteCallback),
+        deleterData_(deleterData) {}
+
+  V8Task(const V8Task &other) = delete;
+  V8Task &operator=(const V8Task &other) = delete;
+
+  ~V8Task() {
+    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 V8TaskRunner {
+ public:
+  static void Create(jsr_config config, std::shared_ptr<facebook::react::MessageQueueThread> queue) {
+    CRASH_ON_ERROR(
+        getV8Api().jsr_config_set_task_runner(config, new V8TaskRunner(std::move(queue)), &PostTask, &Delete, nullptr));
+  }
+
+ private:
+  V8TaskRunner(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<V8Task>(taskData, taskRunCallback, taskDataDeleteCallback, deleterData);
+    reinterpret_cast<V8TaskRunner *>(taskRunnerData)->queue_->runOnQueue([task = std::move(task)] { task->Run(); });
+  }
+
+  static void NAPI_CDECL Delete(void *taskRunner, void * /*deleterData*/) {
+    delete reinterpret_cast<V8TaskRunner *>(taskRunner);
+  }
+
+ private:
+  std::shared_ptr<facebook::react::MessageQueueThread> queue_;
+};
+
+struct V8JsiBuffer : 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 V8JsiBuffer(buffer, bufferSize, bufferDeleteCallback, deleterData));
+  }
+
+  V8JsiBuffer(
+      const uint8_t *buffer,
+      size_t bufferSize,
+      jsr_data_delete_cb bufferDeleteCallback,
+      void *deleterData) noexcept
+      : buffer_(buffer),
+        bufferSize_(bufferSize),
+        bufferDeleteCallback_(bufferDeleteCallback),
+        deleterData_(deleterData) {}
+
+  ~V8JsiBuffer() 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 V8ScriptCache {
+ public:
+  static void Create(jsr_config config, std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore) {
+    CRASH_ON_ERROR(getV8Api().jsr_config_set_script_cache(
+        config, new V8ScriptCache(std::move(scriptStore)), &LoadScript, &StoreScript, &Delete, nullptr));
+  }
+
+ private:
+  V8ScriptCache(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<V8ScriptCache *>(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<V8ScriptCache *>(scriptCache)->scriptStore_;
+    scriptStore->persistPreparedScript(
+        V8JsiBuffer::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<V8ScriptCache *>(scriptCache);
+  }
+
+ private:
+  std::shared_ptr<facebook::jsi::PreparedScriptStore> scriptStore_;
+};
+
+} // namespace
+
+V8RuntimeHolder::V8RuntimeHolder(
+    std::shared_ptr<facebook::react::DevSettings> devSettings,
+    std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
+    std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore,
+    bool enableMultiThreadingSupport) noexcept
+    : m_weakDevSettings(devSettings),
+      m_jsQueue(std::move(jsQueue)),
+      m_preparedScriptStore(std::move(preparedScriptStore)),
+      m_enableMultiThreadingSupport(enableMultiThreadingSupport) {}
+
+void V8RuntimeHolder::initRuntime() noexcept {
+  std::shared_ptr<facebook::react::DevSettings> devSettings = m_weakDevSettings.lock();
+  VerifyElseCrash(devSettings);
+
+  V8Api &api = getV8Api();
+  V8Api::setCurrent(&api);
+  jsr_config config{};
+  CRASH_ON_ERROR(api.jsr_create_config(&config));
+  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));
+  CRASH_ON_ERROR(api.v8_config_enable_multithreading(config, m_enableMultiThreadingSupport));
+
+  if (m_jsQueue) {
+    V8TaskRunner::Create(config, m_jsQueue);
+  }
+  if (m_preparedScriptStore) {
+    V8ScriptCache::Create(config, m_preparedScriptStore);
+  }
+  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(V8Api::current()->jsr_delete_runtime(runtime)); });
+  m_ownThreadId = std::this_thread::get_id();
+}
+
+facebook::react::JSIEngineOverride V8RuntimeHolder::getRuntimeType() noexcept {
+  return facebook::react::JSIEngineOverride::V8NodeApi;
+}
+
+std::shared_ptr<facebook::jsi::Runtime> V8RuntimeHolder::getRuntime() noexcept {
+  std::call_once(m_onceFlag, [this]() { initRuntime(); });
+  VerifyElseCrash(m_jsiRuntime);
+  return m_jsiRuntime;
+}
+
+} // namespace Microsoft::ReactNative

package/Shared/JSI/V8RuntimeHolder.h

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "RuntimeHolder.h"
+#include "ScriptStore.h"
+
+#include <cxxreact/MessageQueueThread.h>
+
+namespace Microsoft::ReactNative {
+
+class V8RuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
+ public: // RuntimeHolderLazyInit implementation.
+  std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept override;
+  facebook::react::JSIEngineOverride getRuntimeType() noexcept override;
+
+  V8RuntimeHolder(
+      std::shared_ptr<facebook::react::DevSettings> devSettings,
+      std::shared_ptr<facebook::react::MessageQueueThread> jsQueue,
+      std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore,
+      bool enableMultiThreadingSupport) noexcept;
+
+ private:
+  void initRuntime() noexcept;
+
+ private:
+  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;
+  bool m_enableMultiThreadingSupport;
+};
+
+} // namespace Microsoft::ReactNative

package/Shared/LayoutAnimation.cpp

@@ -0,0 +1,143 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "LayoutAnimation.h"
+
+#include <folly/dynamic.h>
+#include <exception>
+
+namespace facebook {
+namespace react {
+
+namespace {
+
+constexpr auto c_defaultDelay = 0.0f;
+constexpr auto c_defaultInitialVelocity = 0.0f;
+constexpr auto c_defaultSpringDamping = 0.4f;
+
+constexpr auto c_typeSz = "type";
+constexpr auto c_propertySz = "property";
+
+constexpr auto c_createSz = "create";
+constexpr auto c_updateSz = "update";
+constexpr auto c_deleteSz = "delete";
+
+constexpr auto c_opacitySz = "opacity";
+constexpr auto c_scaleXSz = "scaleX";
+constexpr auto c_scaleXYSz = "scaleXY";
+constexpr auto c_scaleYSz = "scaleY";
+
+constexpr auto c_easeInSz = "easeIn";
+constexpr auto c_easeInEaseOutSz = "easeInEaseOut";
+constexpr auto c_easeOutSz = "easeOut";
+constexpr auto c_linearSz = "linear";
+constexpr auto c_springSz = "spring";
+constexpr auto c_keyboardSz = "keyboard";
+
+constexpr auto c_durationSz = "duration";
+constexpr auto c_delaySz = "delay";
+
+constexpr auto c_initialVelocitySz = "initialVelocity";
+constexpr auto c_springDampingSz = "springDamping";
+
+LayoutAnimation::AnimationType AnimationTypeFromConfig(folly::dynamic &config) {
+  if (config.isNull())
+    return LayoutAnimation::AnimationType::None;
+
+  auto type = config[c_typeSz];
+  if (type == c_easeInSz)
+    return LayoutAnimation::AnimationType::EaseIn;
+  else if (type == c_easeInEaseOutSz)
+    return LayoutAnimation::AnimationType::EaseInEaseOut;
+  else if (type == c_easeOutSz)
+    return LayoutAnimation::AnimationType::EaseOut;
+  else if (type == c_linearSz)
+    return LayoutAnimation::AnimationType::Linear;
+  else if (type == c_springSz)
+    return LayoutAnimation::AnimationType::Spring;
+  else if (type == c_keyboardSz)
+    return LayoutAnimation::AnimationType::Keyboard;
+  else {
+    throw std::exception("Unknown animation type requested for LayoutAnimations.");
+  }
+}
+
+LayoutAnimation::AnimatableProperty AnimatablePropertyFromConfig(folly::dynamic &config) {
+  if (config.isNull())
+    return LayoutAnimation::AnimatableProperty::None;
+
+  auto animProp = config[c_propertySz];
+  if (animProp.isNull())
+    return LayoutAnimation::AnimatableProperty::None;
+  else if (animProp == c_opacitySz)
+    return LayoutAnimation::AnimatableProperty::Opacity;
+  else if (animProp == c_scaleXSz)
+    return LayoutAnimation::AnimatableProperty::ScaleX;
+  else if (animProp == c_scaleYSz)
+    return LayoutAnimation::AnimatableProperty::ScaleY;
+  else if (animProp == c_scaleXYSz)
+    return LayoutAnimation::AnimatableProperty::ScaleXY;
+  else {
+    throw std::exception("Unknown property used for LayoutAnimations.");
+  }
+}
+
+void SetAnimationSpecificProperties(folly::dynamic &&config, LayoutAnimation::LayoutAnimationProperties &props) {
+  if (config.isNull()) {
+    throw std::exception("Cannot set animation-specific properties with null config.");
+  }
+
+  if (config[c_typeSz] == c_springSz) {
+    props.springAnimationProperties.initialVelocity = (config.find(c_initialVelocitySz) != config.items().end())
+        ? static_cast<float>(config[c_initialVelocitySz].asDouble())
+        : c_defaultInitialVelocity;
+    props.springAnimationProperties.springDamping = (config.find(c_springDampingSz) != config.items().end())
+        ? static_cast<float>(config[c_springDampingSz].asDouble())
+        : c_defaultSpringDamping;
+  }
+}
+
+void SetAnimationProperties(
+    folly::dynamic &&config,
+    LayoutAnimation::LayoutAnimationProperties &props,
+    float defaultDuration) {
+  if (config.isNull()) {
+    props.animationType = LayoutAnimation::AnimationType::None;
+    return;
+  }
+
+  props.animationType = AnimationTypeFromConfig(config);
+  props.animatedProp = AnimatablePropertyFromConfig(config);
+  props.delay = (config.find(c_delaySz) != config.items().end()) ? static_cast<float>(config[c_delaySz].asDouble())
+                                                                 : c_defaultDelay;
+  props.duration = (config.find(c_durationSz) != config.items().end())
+      ? static_cast<float>(config[c_durationSz].asDouble())
+      : defaultDuration;
+
+  if (props.animationType == LayoutAnimation::AnimationType::Spring) {
+    SetAnimationSpecificProperties(std::move(config), props);
+  }
+}
+
+} // anonymous namespace
+
+LayoutAnimation::LayoutAnimation(folly::dynamic config) {
+  if (config.isNull()) {
+    throw std::exception("Cannot construct LayoutAnimation with null config.");
+  }
+
+  auto duration = config[c_durationSz];
+
+  if (duration.isNull()) {
+    throw std::exception("LayoutAnimation must include default duration.");
+  }
+
+  auto defaultDuration = static_cast<float>(duration.asDouble()); // duration provided in ms
+
+  SetAnimationProperties(std::move(config[c_createSz]), m_props.createAnimationProps, defaultDuration);
+  SetAnimationProperties(std::move(config[c_updateSz]), m_props.updateAnimationProps, defaultDuration);
+  SetAnimationProperties(std::move(config[c_deleteSz]), m_props.deleteAnimationProps, defaultDuration);
+}
+
+} // namespace react
+} // namespace facebook

package/Shared/LayoutAnimation.h

@@ -0,0 +1,72 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+namespace folly {
+
+struct dynamic;
+
+} // namespace folly
+
+namespace facebook {
+namespace react {
+
+#pragma region Animation - specific properties
+
+struct SpringAnimationProperties {
+  float springDamping;
+  float initialVelocity;
+};
+
+#pragma endregion
+
+class LayoutAnimation {
+ public:
+  enum class AnimationType {
+    EaseIn,
+    EaseInEaseOut,
+    EaseOut,
+    Keyboard,
+    Linear,
+    None,
+    Spring,
+  };
+
+  enum class AnimatableProperty {
+    None,
+    Opacity,
+    ScaleX,
+    ScaleY,
+    ScaleXY,
+  };
+
+  struct LayoutAnimationProperties {
+    float duration = 0.0f;
+    float delay = 0.0f;
+    AnimationType animationType;
+    AnimatableProperty animatedProp;
+
+    union // Animation-specific properties
+    {
+      SpringAnimationProperties springAnimationProperties;
+    };
+  };
+
+  struct LayoutAnimations {
+    LayoutAnimationProperties createAnimationProps;
+    LayoutAnimationProperties deleteAnimationProps;
+    LayoutAnimationProperties updateAnimationProps;
+  };
+
+  LayoutAnimation(folly::dynamic config);
+  const LayoutAnimations &Properties() {
+    return m_props;
+  }
+
+ private:
+  LayoutAnimations m_props;
+};
+
+} // namespace react
+} // namespace facebook

package/Shared/Logging.cpp

@@ -33,7 +33,7 @@ void InitializeLogging(NativeLoggingHook &&hook) {
   JSNativeHooks::loggingHook = LogHook;
   JSNativeHooks::nowHook = nativePerformanceNow;
 
-  ReactMarker::logTaggedMarker = logMarker;
+  ReactMarker::logTaggedMarkerImpl = logMarker;
 }
 
 } // namespace react

package/Shared/MemoryMappedBuffer.cpp

@@ -1,3 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
 #include "pch.h"
 #include "MemoryMappedBuffer.h"
 
@@ -31,23 +34,8 @@ MemoryMappedBuffer::MemoryMappedBuffer(const wchar_t *const filename, uint32_t o
     throw facebook::jsi::JSINativeException("MemoryMappedBuffer constructor is called with nullptr filename.");
   }
 
-  // Because we still need to support Windows 7, and APIs such as CreateFile2
-  // and CreateFileMappingFromApp are only available on Windows 8+, we currently
-  // use APIs such as CreateFileW and CreateFileMapping for Win32.
-#if (defined(WINRT))
   std::unique_ptr<void, decltype(&CloseHandle)> fileHandle{
       CreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, nullptr /* pCreateExParams */), &CloseHandle};
-#else
-  std::unique_ptr<void, decltype(&CloseHandle)> fileHandle{CreateFileW(
-                                                               filename,
-                                                               GENERIC_READ,
-                                                               FILE_SHARE_READ,
-                                                               nullptr /* lpSecurityAttributes */,
-                                                               OPEN_EXISTING,
-                                                               FILE_ATTRIBUTE_NORMAL,
-                                                               nullptr /* hTemplateFile */),
-                                                           &CloseHandle};
-#endif
 
   if (fileHandle.get() == INVALID_HANDLE_VALUE) {
     throw facebook::jsi::JSINativeException(
@@ -74,35 +62,16 @@ MemoryMappedBuffer::MemoryMappedBuffer(const wchar_t *const filename, uint32_t o
     throw facebook::jsi::JSINativeException("Invalid offset.");
   }
 
-#if (defined(WINRT))
   m_fileMapping.reset(CreateFileMappingFromApp(
       fileHandle.get(), nullptr /* SecurityAttributes */, PAGE_READONLY, m_fileSize, nullptr /* Name */));
-#else
-  m_fileMapping.reset(CreateFileMapping(
-      fileHandle.get(),
-      nullptr /* lpAttributes */,
-      PAGE_READONLY,
-      0 /* dwMaximumSizeHigh */,
-      m_fileSize,
-      nullptr /* lpName */));
-#endif
 
   if (!m_fileMapping) {
     throw facebook::jsi::JSINativeException(
         "CreateFileMapping/CreateFileMappingFromApp failed with last error " + std::to_string(GetLastError()));
   }
 
-#if (defined(WINRT))
   m_fileData.reset(
       MapViewOfFileFromApp(m_fileMapping.get(), FILE_MAP_READ, 0 /* FileOffset */, 0 /* NumberOfBytesToMap */));
-#else
-  m_fileData.reset(MapViewOfFile(
-      m_fileMapping.get(),
-      FILE_MAP_READ,
-      0 /* dwFileOffsetHigh */,
-      0 /* dwFileOffsetLow */,
-      0 /* dwNumberOfBytesToMap */));
-#endif
 
   if (!m_fileData) {
     throw facebook::jsi::JSINativeException(
@@ -124,8 +93,8 @@ const uint8_t *MemoryMappedBuffer::data() const {
 
 namespace Microsoft::JSI {
 
-std::shared_ptr<facebook::jsi::Buffer> MakeMemoryMappedBuffer(const wchar_t *const filename, uint32_t offset) {
-  return std::make_shared<MemoryMappedBuffer>(filename, offset);
+std::unique_ptr<facebook::jsi::Buffer> MakeMemoryMappedBuffer(const wchar_t *const filename, uint32_t offset) {
+  return std::make_unique<MemoryMappedBuffer>(filename, offset);
 }
 
 } // namespace Microsoft::JSI

package/Shared/MemoryMappedBuffer.h

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace Microsoft::JSI {
+
+// We only support files whose size can fit within an uint32_t. Memory
+// mapping an empty or a larger file fails.
+std::unique_ptr<facebook::jsi::Buffer> MakeMemoryMappedBuffer(const wchar_t *const filename, uint32_t offset = 0);
+
+} // namespace Microsoft::JSI