react-native-windows 0.71.24 → 0.71.25

package/Shared/Networking/DefaultBlobResource.h

@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IBlobResource.h"
+
+#include <IBlobPersistor.h>
+#include <Modules/IRequestBodyHandler.h>
+#include <Modules/IResponseHandler.h>
+#include <Modules/IWebSocketModuleContentHandler.h>
+
+// React Native Windows
+#include <ReactPropertyBag.h>
+
+// Boost Libraries
+#include <boost/uuid/uuid_generators.hpp>
+
+// Standard Library
+#include <mutex>
+#include <unordered_set>
+
+namespace Microsoft::React::Networking {
+
+class MemoryBlobPersistor final : public IBlobPersistor {
+  std::unordered_map<std::string, std::vector<uint8_t>> m_blobs;
+  std::mutex m_mutex;
+  boost::uuids::random_generator m_guidGenerator;
+
+ public:
+#pragma region IBlobPersistor
+
+  winrt::array_view<uint8_t const> ResolveMessage(std::string &&blobId, int64_t offset, int64_t size) override;
+
+  void RemoveMessage(std::string &&blobId) noexcept override;
+
+  void StoreMessage(std::vector<uint8_t> &&message, std::string &&blobId) noexcept override;
+
+  std::string StoreMessage(std::vector<uint8_t> &&message) noexcept override;
+
+#pragma endregion IBlobPersistor
+};
+
+class BlobWebSocketModuleContentHandler final : public IWebSocketModuleContentHandler {
+  std::unordered_set<int64_t> m_socketIds;
+  std::mutex m_mutex;
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobWebSocketModuleContentHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IWebSocketModuleContentHandler
+
+  void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
+
+  void ProcessMessage(std::vector<uint8_t> &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept
+      override;
+
+#pragma endregion IWebSocketModuleContentHandler
+
+  void Register(int64_t socketID) noexcept;
+
+  void Unregister(int64_t socketID) noexcept;
+};
+
+class BlobModuleRequestBodyHandler final : public IRequestBodyHandler {
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobModuleRequestBodyHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IRequestBodyHandler
+
+  bool Supports(winrt::Microsoft::ReactNative::JSValueObject &data) override;
+
+  winrt::Microsoft::ReactNative::JSValueObject ToRequestBody(
+      winrt::Microsoft::ReactNative::JSValueObject &data,
+      std::string &contentType) override;
+
+#pragma endregion IRequestBodyHandler
+};
+
+class BlobModuleResponseHandler final : public IResponseHandler {
+  std::shared_ptr<IBlobPersistor> m_blobPersistor;
+
+ public:
+  BlobModuleResponseHandler(std::shared_ptr<IBlobPersistor> blobPersistor) noexcept;
+
+#pragma region IResponseHandler
+
+  bool Supports(std::string &responseType) override;
+
+  winrt::Microsoft::ReactNative::JSValueObject ToResponseData(std::vector<uint8_t> &&content) override;
+
+#pragma endregion IResponseHandler
+};
+
+class DefaultBlobResource : public IBlobResource, public std::enable_shared_from_this<DefaultBlobResource> {
+  std::shared_ptr<MemoryBlobPersistor> m_blobPersistor;
+  std::shared_ptr<BlobWebSocketModuleContentHandler> m_contentHandler;
+  std::shared_ptr<BlobModuleRequestBodyHandler> m_requestBodyHandler;
+  std::shared_ptr<BlobModuleResponseHandler> m_responseHandler;
+  winrt::Microsoft::ReactNative::ReactPropertyBag m_propertyBag;
+  BlobCallbacks m_callbacks;
+
+ public:
+  DefaultBlobResource(
+      std::shared_ptr<MemoryBlobPersistor> blobPersistor,
+      std::shared_ptr<BlobWebSocketModuleContentHandler> contentHandler,
+      std::shared_ptr<BlobModuleRequestBodyHandler> requestBodyHandler,
+      std::shared_ptr<BlobModuleResponseHandler> responseHandler,
+      winrt::Microsoft::ReactNative::ReactPropertyBag propertyBag);
+
+#pragma region IBlobResource
+
+  void SendOverSocket(std::string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept override;
+
+  void CreateFromParts(winrt::Microsoft::ReactNative::JSValueArray &&parts, std::string &&blobId) noexcept override;
+
+  void Release(std::string &&blobId) noexcept override;
+
+  void AddNetworkingHandler() noexcept override;
+
+  void AddWebSocketHandler(int64_t id) noexcept override;
+
+  void RemoveWebSocketHandler(int64_t id) noexcept override;
+
+  BlobCallbacks &Callbacks() noexcept override;
+
+#pragma endregion IBlobResource
+};
+
+} // namespace Microsoft::React::Networking

package/Shared/Networking/IBlobResource.h

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <IBlobPersistor.h>
+
+// React Native Windows
+#include <JSValue.h>
+
+// Windows API
+#include <winrt/Windows.Foundation.h>
+
+// Standard Library
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace Microsoft::React::Networking {
+
+struct IBlobResource {
+  struct BlobCallbacks {
+    std::function<void(std::string &&errorText)> OnError;
+  };
+
+  struct BlobFieldNames {
+    const char *Blob;
+    const char *BlobId;
+    const char *Offset;
+    const char *Size;
+    const char *Type;
+    const char *Data;
+  };
+
+  static std::shared_ptr<IBlobResource> Make(winrt::Windows::Foundation::IInspectable const &inspectableProperties);
+
+  static const BlobFieldNames &FieldNames() noexcept;
+
+  virtual ~IBlobResource() noexcept {}
+
+  virtual void SendOverSocket(std::string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept = 0;
+
+  virtual void CreateFromParts(winrt::Microsoft::ReactNative::JSValueArray &&parts, std::string &&blobId) noexcept = 0;
+
+  virtual void Release(std::string &&blobId) noexcept = 0;
+
+  virtual void AddNetworkingHandler() noexcept = 0;
+
+  virtual void AddWebSocketHandler(int64_t id) noexcept = 0;
+
+  virtual void RemoveWebSocketHandler(int64_t id) noexcept = 0;
+
+  virtual BlobCallbacks &Callbacks() noexcept = 0;
+};
+
+} // namespace Microsoft::React::Networking

package/Shared/Networking/IHttpResource.h

@@ -3,8 +3,8 @@
 
 #pragma once
 
-// Folly
-#include <folly/dynamic.h>
+// React Native Windows
+#include <JSValue.h>
 
 // Windows API
 #include <winrt/Windows.Foundation.h>
@@ -20,7 +20,6 @@ namespace Microsoft::React::Networking {
 struct IHttpResource {
   typedef std::unordered_map<std::string, std::string> Headers;
 
-  // TODO: Implement Form data
   struct BodyData {
     enum class Type : size_t { Empty, String, Base64, Uri, Form } Type = Type::Empty;
     std::string Data;
@@ -81,7 +80,7 @@ struct IHttpResource {
       std::string &&url,
       int64_t requestId,
       Headers &&headers,
-      folly::dynamic &&data,
+      winrt::Microsoft::ReactNative::JSValueObject &&data,
       std::string &&responseType,
       bool useIncrementalUpdates,
       int64_t timeout,
@@ -146,7 +145,9 @@ struct IHttpResource {
   ///   Structured response content payload (i.e. Blob data)
   ///   </param>
   /// </param>
-  virtual void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept = 0;
+  virtual void SetOnData(
+      std::function<void(int64_t requestId, winrt::Microsoft::ReactNative::JSValueObject &&responseData)>
+          &&handler) noexcept = 0;
 
   /// <summary>
   /// Sets a function to be invoked when a response content increment has been received.

package/Shared/Networking/WinRTHttpResource.cpp

@@ -23,8 +23,6 @@
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Web.Http.Headers.h>
 
-using folly::dynamic;
-
 using std::function;
 using std::scoped_lock;
 using std::shared_ptr;
@@ -35,6 +33,7 @@ using std::weak_ptr;
 using winrt::fire_and_forget;
 using winrt::hresult_error;
 using winrt::to_hstring;
+using winrt::Microsoft::ReactNative::JSValueObject;
 using winrt::Windows::Foundation::IAsyncOperation;
 using winrt::Windows::Foundation::IInspectable;
 using winrt::Windows::Foundation::Uri;
@@ -69,15 +68,15 @@ constexpr char responseTypeBlob[] = "blob";
 namespace Microsoft::React::Networking {
 
 // May throw winrt::hresult_error
-void AttachMultipartHeaders(IHttpContent content, const dynamic &headers) {
+void AttachMultipartHeaders(IHttpContent content, const JSValueObject &headers) {
   HttpMediaTypeHeaderValue contentType{nullptr};
 
   // Headers are generally case-insensitive
   // https://www.ietf.org/rfc/rfc2616.txt section 4.2
   // TODO: Consolidate with PerformRequest's header parsing.
-  for (auto &header : headers.items()) {
-    auto &name = header.first.getString();
-    auto &value = header.second.getString();
+  for (auto &header : headers) {
+    auto &name = header.first;
+    auto value = header.second.AsString();
 
     if (boost::iequals(name.c_str(), "Content-Type")) {
       contentType = HttpMediaTypeHeaderValue::Parse(to_hstring(value));
@@ -147,6 +146,14 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
         }
         co_return nullptr;
       }
+    } else if (boost::iequals(name.c_str(), "User-Agent")) {
+      bool success = request.Headers().TryAppendWithoutValidation(to_hstring(name), to_hstring(value));
+      if (!success) {
+        if (self->m_onError) {
+          self->m_onError(reqArgs->RequestId, "Failed to append User-Agent", false);
+        }
+        co_return nullptr;
+      }
     } else {
       try {
         request.Headers().Append(to_hstring(name), to_hstring(value));
@@ -162,11 +169,11 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
   // Initialize content
   IHttpContent content{nullptr};
   auto &data = reqArgs->Data;
-  if (!data.isNull()) {
+  if (!data.empty()) {
     auto bodyHandler = self->m_requestBodyHandler.lock();
     if (bodyHandler && bodyHandler->Supports(data)) {
       auto contentTypeString = contentType ? winrt::to_string(contentType.ToString()) : "";
-      dynamic blob;
+      JSValueObject blob;
       try {
         blob = bodyHandler->ToRequestBody(data, contentTypeString);
       } catch (const std::invalid_argument &e) {
@@ -175,44 +182,45 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
         }
         co_return nullptr;
       }
-      auto bytes = blob["bytes"];
+      auto &bytes = blob["bytes"].AsArray();
       auto byteVector = vector<uint8_t>(bytes.size());
       for (auto &byte : bytes) {
-        byteVector.push_back(static_cast<uint8_t>(byte.asInt()));
+        byteVector.push_back(static_cast<uint8_t>(byte.AsUInt8()));
       }
       auto view = winrt::array_view<uint8_t const>{byteVector};
       auto buffer = CryptographicBuffer::CreateFromByteArray(view);
       content = HttpBufferContent{std::move(buffer)};
-    } else if (!data["string"].isNull()) {
-      content = HttpStringContent{to_hstring(data["string"].asString())};
-    } else if (!data["base64"].empty()) {
-      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(data["base64"].asString()));
+    } else if (data.find("string") != data.cend()) {
+      content = HttpStringContent{to_hstring(data["string"].AsString())};
+    } else if (data.find("base64") != data.cend()) {
+      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(data["base64"].AsString()));
       content = HttpBufferContent{std::move(buffer)};
-    } else if (!data["uri"].empty()) {
-      auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(data["uri"].asString())});
+    } else if (data.find("uri") != data.cend()) {
+      auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(data["uri"].AsString())});
       auto stream = co_await file.OpenReadAsync();
       content = HttpStreamContent{std::move(stream)};
-    } else if (!data["formData"].empty()) {
+    } else if (data.find("formData") != data.cend()) {
       winrt::Windows::Web::Http::HttpMultipartFormDataContent multiPartContent;
-      auto formData = data["formData"];
+      auto &formData = data["formData"].AsObject();
 
       // #6046 -  Overwriting WinRT's HttpMultipartFormDataContent implicit Content-Type clears the generated boundary
       contentType = nullptr;
 
       for (auto &formDataPart : formData) {
         IHttpContent formContent{nullptr};
-        if (!formDataPart["string"].isNull()) {
-          formContent = HttpStringContent{to_hstring(formDataPart["string"].asString())};
-        } else if (!formDataPart["uri"].empty()) {
-          auto filePath = to_hstring(formDataPart["uri"].asString());
+        auto &itr = formDataPart.second["string"];
+        if (!formDataPart.second["string"].IsNull()) {
+          formContent = HttpStringContent{to_hstring(formDataPart.second["string"].AsString())};
+        } else if (!formDataPart.second["uri"].IsNull()) {
+          auto filePath = to_hstring(formDataPart.second["uri"].AsString());
           auto file = co_await StorageFile::GetFileFromPathAsync(filePath);
           auto stream = co_await file.OpenReadAsync();
           formContent = HttpStreamContent{stream};
         }
 
         if (formContent) {
-          AttachMultipartHeaders(formContent, formDataPart["headers"]);
-          multiPartContent.Add(formContent, to_hstring(formDataPart["fieldName"].asString()));
+          AttachMultipartHeaders(formContent, formDataPart.second["headers"].AsObject());
+          multiPartContent.Add(formContent, to_hstring(formDataPart.second["fieldName"].AsString()));
         }
       } // foreach form data part
 
@@ -266,7 +274,7 @@ void WinRTHttpResource::SendRequest(
     string &&url,
     int64_t requestId,
     Headers &&headers,
-    dynamic &&data,
+    JSValueObject &&data,
     string &&responseType,
     bool useIncrementalUpdates,
     int64_t timeout,
@@ -345,10 +353,10 @@ void WinRTHttpResource::SetOnData(function<void(int64_t requestId, string &&resp
   m_onData = std::move(handler);
 }
 
-void WinRTHttpResource::SetOnData(function<void(int64_t requestId, dynamic &&responseData)> &&handler) noexcept
+void WinRTHttpResource::SetOnData(function<void(int64_t requestId, JSValueObject &&responseData)> &&handler) noexcept
 /*override*/
 {
-  m_onDataDynamic = std::move(handler);
+  m_onDataObject = std::move(handler);
 }
 
 void WinRTHttpResource::SetOnIncrementalData(
@@ -397,7 +405,7 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
   // Ensure background thread
   co_await winrt::resume_background();
 
-  auto props = winrt::multi_threaded_map<winrt::hstring, IInspectable>();
+  auto props = winrt::single_threaded_map<winrt::hstring, IInspectable>();
   props.Insert(L"RequestArgs", coArgs);
 
   auto coRequestOp = CreateRequest(std::move(coMethod), std::move(coUri), props);
@@ -418,8 +426,8 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
     try {
       if (uriHandler->Supports(uri, reqArgs->ResponseType)) {
         auto blob = uriHandler->Fetch(uri);
-        if (self->m_onDataDynamic && self->m_onRequestSuccess) {
-          self->m_onDataDynamic(reqArgs->RequestId, std::move(blob));
+        if (self->m_onDataObject && self->m_onRequestSuccess) {
+          self->m_onDataObject(reqArgs->RequestId, std::move(blob));
           self->m_onRequestSuccess(reqArgs->RequestId);
         }
 
@@ -528,8 +536,8 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
 
           auto blob = responseHandler->ToResponseData(std::move(responseData));
 
-          if (self->m_onDataDynamic && self->m_onRequestSuccess) {
-            self->m_onDataDynamic(reqArgs->RequestId, std::move(blob));
+          if (self->m_onDataObject && self->m_onRequestSuccess) {
+            self->m_onDataObject(reqArgs->RequestId, std::move(blob));
             self->m_onRequestSuccess(reqArgs->RequestId);
           }
 

package/Shared/Networking/WinRTHttpResource.h

@@ -28,7 +28,7 @@ class WinRTHttpResource : public IHttpResource,
   std::function<void(int64_t requestId)> m_onRequestSuccess;
   std::function<void(int64_t requestId, Response &&response)> m_onResponse;
   std::function<void(int64_t requestId, std::string &&responseData)> m_onData;
-  std::function<void(int64_t requestId, folly::dynamic &&responseData)> m_onDataDynamic;
+  std::function<void(int64_t requestId, winrt::Microsoft::ReactNative::JSValueObject &&responseData)> m_onDataObject;
   std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> m_onError;
   std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
       m_onIncrementalData;
@@ -71,7 +71,7 @@ class WinRTHttpResource : public IHttpResource,
       std::string &&url,
       int64_t requestId,
       Headers &&headers,
-      folly::dynamic &&data,
+      winrt::Microsoft::ReactNative::JSValueObject &&data,
       std::string &&responseType,
       bool useIncrementalUpdates,
       int64_t timeout,
@@ -83,7 +83,8 @@ class WinRTHttpResource : public IHttpResource,
   void SetOnRequestSuccess(std::function<void(int64_t requestId)> &&handler) noexcept override;
   void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept override;
   void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept override;
-  void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept override;
+  void SetOnData(std::function<void(int64_t requestId, winrt::Microsoft::ReactNative::JSValueObject &&responseData)>
+                     &&handler) noexcept override;
   void SetOnIncrementalData(
       std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
           &&handler) noexcept override;

package/Shared/Networking/WinRTTypes.h

@@ -5,8 +5,8 @@
 
 #include "IHttpResource.h"
 
-// Folly
-#include <folly/dynamic.h>
+// React Native Windows
+#include <JSValue.h>
 
 // Windows API
 #include <winrt/Windows.Web.Http.h>
@@ -19,7 +19,7 @@ namespace Microsoft::React::Networking {
 struct RequestArgs : public winrt::implements<RequestArgs, winrt::Windows::Foundation::IInspectable> {
   int64_t RequestId;
   IHttpResource::Headers Headers;
-  folly::dynamic Data;
+  winrt::Microsoft::ReactNative::JSValueObject Data;
   bool IncrementalUpdates;
   bool WithCredentials;
   std::string ResponseType;

package/Shared/OInstance.cpp

@@ -52,13 +52,11 @@
 #include "HermesRuntimeHolder.h"
 
 #if defined(USE_V8)
-#include <JSI/NapiJsiV8RuntimeHolder.h>
-
-#include "BaseScriptStoreImpl.h"
-#include "V8JSIRuntimeHolder.h"
+#include <JSI/V8RuntimeHolder.h>
 #endif
 #include <ReactCommon/CallInvoker.h>
 #include <ReactCommon/TurboModuleBinding.h>
+#include "BaseScriptStoreImpl.h"
 #include "ChakraRuntimeHolder.h"
 
 #include <tracing/tracing.h>
@@ -318,46 +316,32 @@ InstanceImpl::InstanceImpl(
     } else {
       assert(m_devSettings->jsiEngineOverride != JSIEngineOverride::Default);
       switch (m_devSettings->jsiEngineOverride) {
-        case JSIEngineOverride::Hermes:
-          m_devSettings->jsiRuntimeHolder = std::make_shared<HermesRuntimeHolder>(m_devSettings, m_jsThread);
-          break;
-        case JSIEngineOverride::V8: {
-#if defined(USE_V8)
-          std::unique_ptr<facebook::jsi::ScriptStore> scriptStore = nullptr;
-          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore = nullptr;
+        case JSIEngineOverride::Hermes: {
+          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
 
-          char tempPath[MAX_PATH];
-          if (GetTempPathA(MAX_PATH, tempPath)) {
-            preparedScriptStore = std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(tempPath);
+          wchar_t tempPath[MAX_PATH];
+          if (GetTempPathW(MAX_PATH, tempPath)) {
+            preparedScriptStore =
+                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
           }
 
-          m_devSettings->jsiRuntimeHolder = std::make_shared<facebook::react::V8JSIRuntimeHolder>(
-              m_devSettings, m_jsThread, std::move(scriptStore), std::move(preparedScriptStore));
+          m_devSettings->jsiRuntimeHolder = std::make_shared<Microsoft::ReactNative::HermesRuntimeHolder>(
+              m_devSettings, m_jsThread, std::move(preparedScriptStore));
           break;
-#else
-          assert(false); // V8 is not available in this build, fallthrough
-          [[fallthrough]];
-#endif
         }
+        case JSIEngineOverride::V8:
         case JSIEngineOverride::V8NodeApi: {
 #if defined(USE_V8)
-          std::unique_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
+          std::shared_ptr<facebook::jsi::PreparedScriptStore> preparedScriptStore;
 
           wchar_t tempPath[MAX_PATH];
-          if (GetTempPathW(static_cast<DWORD>(std::size(tempPath)), tempPath)) {
+          if (GetTempPathW(MAX_PATH, tempPath)) {
             preparedScriptStore =
-                std::make_unique<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
-          }
-
-          if (!preparedScriptStore) {
-            if (m_devSettings->errorCallback)
-              m_devSettings->errorCallback("Could not initialize prepared script store");
-
-            break;
+                std::make_shared<facebook::react::BasePreparedScriptStoreImpl>(winrt::to_string(tempPath));
           }
 
-          m_devSettings->jsiRuntimeHolder = make_shared<NapiJsiV8RuntimeHolder>(
-              m_devSettings, m_jsThread, nullptr /*scriptStore*/, std::move(preparedScriptStore));
+          m_devSettings->jsiRuntimeHolder = make_shared<Microsoft::ReactNative::V8RuntimeHolder>(
+              m_devSettings, m_jsThread, std::move(preparedScriptStore), false);
           break;
 #else
           if (m_devSettings->errorCallback)
@@ -637,7 +621,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
       nativeQueue));
 
   // These modules are instantiated separately in MSRN (Universal Windows).
-  // When there are module name colisions, the last one registered is used.
+  // When there are module name collisions, the last one registered is used.
   // If this code is enabled, we will have unused module instances.
   // Also, MSRN has a different property bag mechanism incompatible with this method's transitionalProps variable.
 #if (defined(_MSC_VER) && !defined(WINRT))

package/Shared/SafeLoadLibrary.cpp

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "SafeLoadLibrary.h"
+
+namespace Microsoft::ReactNative {
+
+// Unsafe calls to LoadLibrary/LoadLibraryEx.
+// The default behavior of LoadLibrary, or LoadLibraryEx without flags, is to try and find the dependency by iterating
+// through a search order. This search order contains the current working directory. In the classic attack, a malicious
+// DLL is dropped in the likely - controllable current working directory. The malicious DLL has the same name as a
+// missing dependency or dependency that is not in the same directory as the executable. When the call to LoadLibrary
+// is reached, the malicious DLL is loaded preferentially, and code execution occurs.
+//
+// The SafeLoadLibrary is the preferred ways to manually load dependencies.
+// The API does not search the current working directory when resolving dependencies.
+// The implementation is "borrowed" from Office MsoSafeLoadLibrary.
+
+/**
+      List of new flags that control where to search for DLLs. Requires KB2533623.
+*/
+const DWORD SafeLoadLibraryFlags = LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS |
+    LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32 | LOAD_LIBRARY_SEARCH_USER_DIRS;
+
+HMODULE SafeLoadLibrary(const wchar_t *wzFileName, HANDLE hFile, DWORD dwFlags) noexcept {
+  // When calling LoadLibrary, OR in LOAD_LIBRARY_SEARCH_DEFAULT_DIRS which enables all of the
+  // safe behaviors. Note that this flag is not compatible with LOAD_WITH_ALTERED_SEARCH_PATH.
+  HMODULE module =
+      LoadLibraryExW(wzFileName, hFile, (dwFlags | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS) & ~LOAD_WITH_ALTERED_SEARCH_PATH);
+  if (module == nullptr && GetLastError() == ERROR_INVALID_PARAMETER) {
+    // Could have failed with actual bad parameters or an unpatched OS without KB2533623.
+    if (GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "AddDllDirectory") == nullptr) {
+      // Unpatched OS, remove all new flags.
+      module = LoadLibraryExW(wzFileName, hFile, dwFlags & ~SafeLoadLibraryFlags);
+    }
+  }
+
+  return module;
+}
+
+} // namespace Microsoft::ReactNative

package/Shared/SafeLoadLibrary.h

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+namespace Microsoft::ReactNative {
+
+// Safe LoadLibraryEx wrapper that must be used instead of LoadLibrary.
+extern HMODULE SafeLoadLibrary(const wchar_t *wzFileName, HANDLE hFile = nullptr, DWORD dwFlags = 0) noexcept;
+
+} // namespace Microsoft::ReactNative