react-native-windows 0.68.3 → 0.69.0-preview.1

package/Shared/DevSupportManager.cpp

@@ -33,6 +33,7 @@
 #pragma warning(pop)
 
 #include <future>
+#include <mutex>
 
 #include <AppModel.h>
 
@@ -69,13 +70,13 @@ std::future<std::pair<std::string, bool>> GetJavaScriptFromServerAsync(const std
 
   HRESULT hr = asyncRequest.ErrorCode();
   if (FAILED(hr)) {
-    std::ostringstream sstream;
+    std::string error;
     if (hr == WININET_E_CANNOT_CONNECT) {
-      sstream << "A connection with the server " << url << " could not be established\n\nIs the packager running?";
+      error = fmt::format("A connection with the server {} could not be established.\n\nIs the packager running?", url);
     } else {
-      sstream << "Error " << std::hex << static_cast<int>(asyncRequest.ErrorCode()) << " downloading " << url;
+      error = fmt::format("Error 0x{:x} downloading {}.", static_cast<int>(asyncRequest.ErrorCode()), url);
     }
-    co_return std::make_pair(sstream.str(), false);
+    co_return std::make_pair(error, false);
   }
 
   winrt::Windows::Web::Http::HttpResponseMessage response = asyncRequest.GetResults();
@@ -88,15 +89,15 @@ std::future<std::pair<std::string, bool>> GetJavaScriptFromServerAsync(const std
   uint32_t len = reader.UnconsumedBufferLength();
   std::string result;
   if (len > 0 || response.IsSuccessStatusCode()) {
-    std::vector<uint8_t> data;
+    std::string data;
     data.resize(len);
-    reader.ReadBytes(winrt::array_view(data.data(), data.data() + len));
-    data.resize(len);
-    result = std::string(data.begin(), data.end());
+    auto buf = reinterpret_cast<uint8_t *>(data.data());
+    static_assert(
+        sizeof(buf[0]) == sizeof(data[0]), "perf optimization relies on uint8_t and char being the same size");
+    reader.ReadBytes(winrt::array_view(buf, buf + len));
+    result = std::move(data);
   } else {
-    std::ostringstream sstream;
-    sstream << "HTTP Error " << static_cast<int>(response.StatusCode()) << " downloading " << url;
-    result = sstream.str();
+    result = fmt::format("HTTP Error {} downloading {}.", static_cast<int>(response.StatusCode()), url);
   }
 
   co_return std::make_pair(std::move(result), response.IsSuccessStatusCode());
@@ -239,37 +240,32 @@ void DevSupportManager::StopPollingLiveReload() {
   m_cancellation_token = true;
 }
 
-void DevSupportManager::StartInspector(
+void DevSupportManager::EnsureHermesInspector(
     [[maybe_unused]] const std::string &packagerHost,
     [[maybe_unused]] const uint16_t packagerPort) noexcept {
 #ifdef HERMES_ENABLE_DEBUGGER
-  std::string packageName("RNW");
-  wchar_t fullName[PACKAGE_FULL_NAME_MAX_LENGTH]{};
-  UINT32 size = ARRAYSIZE(fullName);
-  if (SUCCEEDED(GetCurrentPackageFullName(&size, fullName))) {
-    // we are in an unpackaged app
-    packageName = winrt::to_string(fullName);
-  }
+  static std::once_flag once;
+  std::call_once(once, [this, &packagerHost, packagerPort]() {
+    std::string packageName("RNW");
+    wchar_t fullName[PACKAGE_FULL_NAME_MAX_LENGTH]{};
+    UINT32 size = ARRAYSIZE(fullName);
+    if (SUCCEEDED(GetCurrentPackageFullName(&size, fullName))) {
+      // we are in an unpackaged app
+      packageName = winrt::to_string(fullName);
+    }
 
-  std::string deviceName("RNWHost");
-  auto hostNames = winrt::Windows::Networking::Connectivity::NetworkInformation::GetHostNames();
-  if (hostNames && hostNames.First() && hostNames.First().Current()) {
-    deviceName = winrt::to_string(hostNames.First().Current().DisplayName());
-  }
+    std::string deviceName("RNWHost");
+    auto hostNames = winrt::Windows::Networking::Connectivity::NetworkInformation::GetHostNames();
+    if (hostNames && hostNames.First() && hostNames.First().Current()) {
+      deviceName = winrt::to_string(hostNames.First().Current().DisplayName());
+    }
 
-  m_inspectorPackagerConnection = std::make_shared<InspectorPackagerConnection>(
-      facebook::react::DevServerHelper::get_InspectorDeviceUrl(packagerHost, packagerPort, deviceName, packageName),
-      m_BundleStatusProvider);
-  m_inspectorPackagerConnection->connectAsync();
-#endif
-}
+    m_inspectorPackagerConnection = std::make_shared<InspectorPackagerConnection>(
+        facebook::react::DevServerHelper::get_InspectorDeviceUrl(packagerHost, packagerPort, deviceName, packageName),
+        m_BundleStatusProvider);
+    m_inspectorPackagerConnection->connectAsync();
+  });
 
-void DevSupportManager::StopInspector() noexcept {
-#ifdef HERMES_ENABLE_DEBUGGER
-  if (m_inspectorPackagerConnection) {
-    m_inspectorPackagerConnection->disconnectAsync();
-    m_inspectorPackagerConnection = nullptr;
-  }
 #endif
 }
 

package/Shared/DevSupportManager.h

@@ -50,8 +50,7 @@ class DevSupportManager final : public facebook::react::IDevSupportManager {
       std::function<void()> onChangeCallback) override;
   virtual void StopPollingLiveReload() override;
 
-  virtual void StartInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
-  virtual void StopInspector() noexcept override;
+  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept override;
   virtual void UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept override;
 
  private:

package/Shared/HermesRuntimeHolder.cpp

@@ -74,7 +74,15 @@ class HermesExecutorRuntimeAdapter final : public facebook::hermes::inspector::R
 } // namespace
 
 void HermesRuntimeHolder::crashHandler(int fileDescriptor) noexcept {
-  HermesShim::hermesCrashHandler(static_cast<facebook::hermes::HermesRuntime &>(*m_runtime), fileDescriptor);
+  HermesShim::hermesCrashHandler(*m_hermesRuntime, fileDescriptor);
+}
+
+void HermesRuntimeHolder::teardown() noexcept {
+#ifdef HERMES_ENABLE_DEBUGGER
+  if (auto devSettings = m_weakDevSettings.lock(); devSettings && devSettings->useDirectDebugger) {
+    facebook::hermes::inspector::chrome::disableDebugging(*m_hermesRuntime);
+  }
+#endif
 }
 
 facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcept {
@@ -84,43 +92,44 @@ facebook::react::JSIEngineOverride HermesRuntimeHolder::getRuntimeType() noexcep
 std::shared_ptr<jsi::Runtime> HermesRuntimeHolder::getRuntime() noexcept {
   std::call_once(m_once_flag, [this]() { initRuntime(); });
 
-  if (!m_runtime)
+  if (!m_hermesRuntime)
     std::terminate();
 
   // Make sure that the runtime instance is not consumed from multiple threads.
   if (m_own_thread_id != std::this_thread::get_id())
     std::terminate();
 
-  return m_runtime;
+  return m_hermesRuntime;
 }
 
 HermesRuntimeHolder::HermesRuntimeHolder(
     std::shared_ptr<facebook::react::DevSettings> devSettings,
     std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept
-    : m_devSettings(std::move(devSettings)), m_jsQueue(std::move(jsQueue)) {}
+    : m_weakDevSettings(devSettings), m_jsQueue(std::move(jsQueue)) {}
 
 void HermesRuntimeHolder::initRuntime() noexcept {
-  auto hermesRuntime = makeHermesRuntimeSystraced(m_devSettings->enableDefaultCrashHandler);
-
-  facebook::hermes::HermesRuntime &hermesRuntimeRef = *hermesRuntime;
+  auto devSettings = m_weakDevSettings.lock();
+  if (!devSettings)
+    std::terminate();
 
-  m_runtime = std::move(hermesRuntime);
+  m_hermesRuntime = makeHermesRuntimeSystraced(devSettings->enableDefaultCrashHandler);
   m_own_thread_id = std::this_thread::get_id();
 
 #ifdef HERMES_ENABLE_DEBUGGER
-  if (m_devSettings->useDirectDebugger) {
-    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_runtime, hermesRuntimeRef, m_jsQueue);
+  if (devSettings->useDirectDebugger) {
+    auto adapter = std::make_unique<HermesExecutorRuntimeAdapter>(m_hermesRuntime, *m_hermesRuntime, m_jsQueue);
     facebook::hermes::inspector::chrome::enableDebugging(
         std::move(adapter),
-        m_devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : m_devSettings->debuggerRuntimeName);
+        devSettings->debuggerRuntimeName.empty() ? "Hermes React Native" : devSettings->debuggerRuntimeName);
   }
 #endif
 
   // Add js engine information to Error.prototype so in error reporting we
   // can send this information.
-  auto errorPrototype =
-      m_runtime->global().getPropertyAsObject(*m_runtime, "Error").getPropertyAsObject(*m_runtime, "prototype");
-  errorPrototype.setProperty(*m_runtime, "jsEngine", "hermes");
+  auto errorPrototype = m_hermesRuntime->global()
+                            .getPropertyAsObject(*m_hermesRuntime, "Error")
+                            .getPropertyAsObject(*m_hermesRuntime, "prototype");
+  errorPrototype.setProperty(*m_hermesRuntime, "jsEngine", "hermes");
 }
 
 } // namespace react

package/Shared/HermesRuntimeHolder.h

@@ -9,6 +9,10 @@
 
 #include <DevSettings.h>
 
+namespace facebook::hermes {
+class HermesRuntime;
+}
+
 namespace facebook {
 namespace react {
 
@@ -19,18 +23,20 @@ class HermesRuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
 
   void crashHandler(int fileDescriptor) noexcept override;
 
+  void teardown() noexcept override;
+
   HermesRuntimeHolder(
       std::shared_ptr<facebook::react::DevSettings> devSettings,
       std::shared_ptr<facebook::react::MessageQueueThread> jsQueue) noexcept;
 
  private:
   void initRuntime() noexcept;
-  std::shared_ptr<facebook::jsi::Runtime> m_runtime;
+  std::shared_ptr<facebook::hermes::HermesRuntime> m_hermesRuntime;
 
   std::once_flag m_once_flag;
   std::thread::id m_own_thread_id;
 
-  std::shared_ptr<facebook::react::DevSettings> m_devSettings;
+  std::weak_ptr<facebook::react::DevSettings> m_weakDevSettings;
   std::shared_ptr<facebook::react::MessageQueueThread> m_jsQueue;
 };
 

package/Shared/IDevSupportManager.h

@@ -22,8 +22,7 @@ struct IDevSupportManager {
       std::function<void()> onChangeCallback) = 0;
   virtual void StopPollingLiveReload() = 0;
 
-  virtual void StartInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
-  virtual void StopInspector() noexcept = 0;
+  virtual void EnsureHermesInspector(const std::string &packagerHost, const uint16_t packagerPort) noexcept = 0;
   virtual void UpdateBundleStatus(bool isLastDownloadSucess, int64_t updateTimestamp) noexcept = 0;
 };
 

package/Shared/InspectorPackagerConnection.cpp

@@ -196,7 +196,8 @@ InspectorPackagerConnection::InspectorPackagerConnection(
 winrt::fire_and_forget InspectorPackagerConnection::disconnectAsync() {
   co_await winrt::resume_background();
   std::string reason("Explicit close");
-  m_packagerWebSocketConnection->Close(Microsoft::React::WinRTWebSocketResource::CloseCode::GoingAway, reason);
+  m_packagerWebSocketConnection->Close(
+      Microsoft::React::Networking::WinRTWebSocketResource::CloseCode::GoingAway, reason);
   co_return;
 }
 
@@ -204,9 +205,10 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
   co_await winrt::resume_background();
 
   std::vector<winrt::Windows::Security::Cryptography::Certificates::ChainValidationResult> certExceptions;
-  m_packagerWebSocketConnection = std::make_shared<Microsoft::React::WinRTWebSocketResource>(std::move(certExceptions));
+  m_packagerWebSocketConnection =
+      std::make_shared<Microsoft::React::Networking::WinRTWebSocketResource>(std::move(certExceptions));
 
-  m_packagerWebSocketConnection->SetOnError([](const Microsoft::React::IWebSocketResource::Error &err) {
+  m_packagerWebSocketConnection->SetOnError([](const Microsoft::React::Networking::IWebSocketResource::Error &err) {
     facebook::react::tracing::error(err.Message.c_str());
   });
 
@@ -267,8 +269,8 @@ winrt::fire_and_forget InspectorPackagerConnection::connectAsync() {
         }
       });
 
-  Microsoft::React::IWebSocketResource::Protocols protocols;
-  Microsoft::React::IWebSocketResource::Options options;
+  Microsoft::React::Networking::IWebSocketResource::Protocols protocols;
+  Microsoft::React::Networking::IWebSocketResource::Options options;
   m_packagerWebSocketConnection->Connect(std::string{m_url}, protocols, options);
 
   co_return;

package/Shared/InspectorPackagerConnection.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include <InspectorProxy.h>
-#include <WinRTWebSocketResource.h>
+#include <Networking/WinRTWebSocketResource.h>
 #include <jsinspector/InspectorInterfaces.h>
 
 namespace Microsoft::ReactNative {
@@ -42,7 +42,7 @@ class InspectorPackagerConnection final : public std::enable_shared_from_this<In
   void sendMessageToVM(int64_t pageId, std::string &&message);
 
   std::unordered_map<int64_t, std::unique_ptr<facebook::react::ILocalConnection>> m_localConnections;
-  std::shared_ptr<Microsoft::React::WinRTWebSocketResource> m_packagerWebSocketConnection;
+  std::shared_ptr<Microsoft::React::Networking::WinRTWebSocketResource> m_packagerWebSocketConnection;
   std::shared_ptr<IBundleStatusProvider> m_bundleStatusProvider;
   std::string m_url;
 };

package/Shared/JSI/ChakraApi.cpp

@@ -3,7 +3,6 @@
 
 #include "ChakraApi.h"
 
-#include <RuntimeOptions.h>
 #include <sstream>
 #include <utility>
 #include "Unicode.h"

package/Shared/JSI/ChakraRuntime.cpp

@@ -4,7 +4,6 @@
 #include "ChakraRuntime.h"
 #include "ChakraRuntimeFactory.h"
 
-#include <RuntimeOptions.h>
 #include "Unicode.h"
 #include "Utilities.h"
 
@@ -991,7 +990,7 @@ size_t ChakraRuntime::JsiValueViewArgs::Size() const noexcept {
 
 ChakraRuntime::PropNameIDView::PropNameIDView(JsPropertyIdRef propertyId) noexcept
     : m_propertyId{
-          make<facebook::jsi::PropNameID>(new (std::addressof(m_pointerStore)) ChakraPointerValueView(propertyId))} {}
+          make<facebook::jsi::PropNameID>(new(std::addressof(m_pointerStore)) ChakraPointerValueView(propertyId))} {}
 
 ChakraRuntime::PropNameIDView::~PropNameIDView() noexcept {}
 

package/Shared/JSI/RuntimeHolder.h

@@ -18,6 +18,8 @@ struct RuntimeHolderLazyInit {
   virtual std::shared_ptr<facebook::jsi::Runtime> getRuntime() noexcept = 0;
   virtual facebook::react::JSIEngineOverride getRuntimeType() noexcept = 0;
 
+  virtual void teardown() noexcept {};
+
   // You can call this when a crash happens to attempt recording additional data
   // The fd supplied is a raw file stream an implementation might write JSON to
   virtual void crashHandler(int fileDescriptor) noexcept {};

package/Shared/Modules/HttpModule.cpp

@@ -17,7 +17,7 @@ using std::weak_ptr;
 
 namespace {
 
-using Microsoft::React::IHttpResource;
+using Microsoft::React::Networking::IHttpResource;
 
 constexpr char moduleName[] = "Networking";
 

package/Shared/Modules/HttpModule.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "IHttpResource.h"
+#include <Networking/IHttpResource.h>
 
 // React Native
 #include <cxxreact/CxxModule.h>
@@ -47,7 +47,7 @@ class HttpModule : public facebook::xplat::module::CxxModule {
     HttpModule *Module{nullptr};
   };
 
-  std::shared_ptr<IHttpResource> m_resource;
+  std::shared_ptr<Networking::IHttpResource> m_resource;
   std::shared_ptr<ModuleHolder> m_holder;
 };
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.cpp

@@ -26,8 +26,8 @@ using std::string;
 using std::weak_ptr;
 
 namespace {
-using Microsoft::React::IWebSocketResource;
 using Microsoft::React::WebSocketModule;
+using Microsoft::React::Networking::IWebSocketResource;
 
 constexpr char moduleName[] = "WebSocketModule";
 

package/Shared/Modules/WebSocketModule.h

@@ -3,8 +3,10 @@
 
 #pragma once
 
+#include <Networking/IWebSocketResource.h>
+
+// React Native
 #include <cxxreact/CxxModule.h>
-#include "IWebSocketResource.h"
 
 namespace Microsoft::React {
 
@@ -25,12 +27,12 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
     /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
     /// As defined in WebSocket.js.
     /// </summary>
-    std::map<int64_t, std::shared_ptr<IWebSocketResource>> ResourceMap{};
+    std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> ResourceMap{};
 
     /// <summary>
     /// Generates IWebSocketResource instances, defaulting to IWebSocketResource::Make.
     /// </summary>
-    std::function<std::shared_ptr<IWebSocketResource>(std::string &&)> ResourceFactory;
+    std::function<std::shared_ptr<Networking::IWebSocketResource>(std::string &&)> ResourceFactory;
 
     /// <summary>
     /// Keeps a raw reference to the module object to lazily retrieve the React Instance as needed.
@@ -58,14 +60,15 @@ class WebSocketModule : public facebook::xplat::module::CxxModule {
 
 #pragma endregion CxxModule overrides
 
-  void SetResourceFactory(std::function<std::shared_ptr<IWebSocketResource>(const std::string &)> &&resourceFactory);
+  void SetResourceFactory(
+      std::function<std::shared_ptr<Networking::IWebSocketResource>(const std::string &)> &&resourceFactory);
 
  private:
   /// <summary>
   /// Keeps <c>IWebSocketResource</c> instances identified by <c>id</c>.
   /// As defined in WebSocket.js.
   /// </summary>
-  std::map<int64_t, std::shared_ptr<IWebSocketResource>> m_webSockets;
+  std::map<int64_t, std::shared_ptr<Networking::IWebSocketResource>> m_webSockets;
 
   /// <summary>
   /// Keeps members that can be accessed threads other than this module's owner accessible.

package/Shared/{IHttpResource.h → Networking/IHttpResource.h}

@@ -9,7 +9,7 @@
 #include <string>
 #include <unordered_map>
 
-namespace Microsoft::React {
+namespace Microsoft::React::Networking {
 
 struct IHttpResource {
   typedef std::unordered_map<std::string, std::string> Headers;
@@ -21,8 +21,8 @@ struct IHttpResource {
 
   struct Response {
     int64_t StatusCode;
-    Headers Headers;
     std::string Url;
+    Headers Headers;
   };
 
   static std::shared_ptr<IHttpResource> Make() noexcept;
@@ -43,11 +43,11 @@ struct IHttpResource {
 
   virtual void ClearCookies() noexcept = 0;
 
-  virtual void SetOnRequest(std::function<void(int64_t requestId)> &&handler) noexcept = 0; // TODO: Keep???
+  virtual void SetOnRequest(std::function<void(int64_t requestId)> &&handler) noexcept = 0;
   virtual void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept = 0;
   virtual void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept = 0;
   virtual void SetOnError(
       std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)> &&handler) noexcept = 0;
 };
 
-} // namespace Microsoft::React
+} // namespace Microsoft::React::Networking

package/Shared/{IWebSocketResource.h → Networking/IWebSocketResource.h}

@@ -8,7 +8,7 @@
 #include <string>
 #include <vector>
 
-namespace Microsoft::React {
+namespace Microsoft::React::Networking {
 
 /// <summary>
 /// Defines the core functionality for a native WebSocket client resource.
@@ -181,4 +181,4 @@ struct IWebSocketResource {
   virtual void SetOnError(std::function<void(Error &&)> &&handler) noexcept = 0;
 };
 
-} // namespace Microsoft::React
+} // namespace Microsoft::React::Networking

package/Shared/Networking/OriginPolicy.h

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+namespace Microsoft::React::Networking {
+
+enum class OriginPolicy : size_t {
+  None = 0,
+  SameOrigin = 1,
+  SimpleCrossOriginResourceSharing = 2,
+  CrossOriginResourceSharing = 3, // TODO: Rename as FullCrossOriginResourceSharing?
+};
+
+} // namespace Microsoft::React::Networking