react-native-windows 0.76.7 → 0.76.9

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/runtime/ReactInstance.cpp

@@ -204,47 +204,51 @@ std::string simpleBasename(const std::string& path) {
  */
 void ReactInstance::loadScript(
     std::unique_ptr<const JSBigString> script,
-    const std::string& sourceURL) {
+    const std::string& sourceURL,
+    std::function<void(jsi::Runtime& runtime)>&& completion) {
   auto buffer = std::make_shared<BigStringBuffer>(std::move(script));
   std::string scriptName = simpleBasename(sourceURL);
 
-  runtimeScheduler_->scheduleWork(
-      [this,
-       scriptName,
-       sourceURL,
-       buffer = std::move(buffer),
-       weakBufferedRuntimeExecuter = std::weak_ptr<BufferedRuntimeExecutor>(
-           bufferedRuntimeExecutor_)](jsi::Runtime& runtime) {
-        SystraceSection s("ReactInstance::loadScript");
-        bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
-        if (hasLogger) {
-          ReactMarker::logTaggedMarkerBridgeless(
-              ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
-        }
+  runtimeScheduler_->scheduleWork([this,
+                                   scriptName,
+                                   sourceURL,
+                                   buffer = std::move(buffer),
+                                   weakBufferedRuntimeExecuter =
+                                       std::weak_ptr<BufferedRuntimeExecutor>(
+                                           bufferedRuntimeExecutor_),
+                                   completion](jsi::Runtime& runtime) {
+    SystraceSection s("ReactInstance::loadScript");
+    bool hasLogger(ReactMarker::logTaggedMarkerBridgelessImpl);
+    if (hasLogger) {
+      ReactMarker::logTaggedMarkerBridgeless(
+          ReactMarker::RUN_JS_BUNDLE_START, scriptName.c_str());
+    }
 
-        runtime.evaluateJavaScript(buffer, sourceURL);
+    runtime.evaluateJavaScript(buffer, sourceURL);
 
-        /**
-         * TODO(T183610671): We need a safe/reliable way to enable the js
-         * pipeline from javascript. Remove this after we figure that out, or
-         * after we just remove the js pipeline.
-         */
-        if (!jsErrorHandler_->hasHandledFatalError()) {
-          jsErrorHandler_->setRuntimeReady();
-        }
+    /**
+     * TODO(T183610671): We need a safe/reliable way to enable the js
+     * pipeline from javascript. Remove this after we figure that out, or
+     * after we just remove the js pipeline.
+     */
+    if (!jsErrorHandler_->hasHandledFatalError()) {
+      jsErrorHandler_->setRuntimeReady();
+    }
 
-        if (hasLogger) {
-          ReactMarker::logTaggedMarkerBridgeless(
-              ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
-          ReactMarker::logMarkerBridgeless(
-              ReactMarker::INIT_REACT_RUNTIME_STOP);
-          ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_STOP);
-        }
-        if (auto strongBufferedRuntimeExecuter =
-                weakBufferedRuntimeExecuter.lock()) {
-          strongBufferedRuntimeExecuter->flush();
-        }
-      });
+    if (hasLogger) {
+      ReactMarker::logTaggedMarkerBridgeless(
+          ReactMarker::RUN_JS_BUNDLE_STOP, scriptName.c_str());
+      ReactMarker::logMarkerBridgeless(ReactMarker::INIT_REACT_RUNTIME_STOP);
+      ReactMarker::logMarkerBridgeless(ReactMarker::APP_STARTUP_STOP);
+    }
+    if (auto strongBufferedRuntimeExecuter =
+            weakBufferedRuntimeExecuter.lock()) {
+      strongBufferedRuntimeExecuter->flush();
+    }
+    if (completion) {
+      completion(runtime);
+    }
+  });
 }
 
 /*

package/Shared/InspectorPackagerConnection.cpp

@@ -148,17 +148,14 @@ InspectorPackagerConnection::InspectorPackagerConnection(
 winrt::fire_and_forget InspectorPackagerConnection::disconnectAsync() {
   co_await winrt::resume_background();
   std::string reason("Explicit close");
-  m_packagerWebSocketConnection->Close(
-      Microsoft::React::Networking::WinRTWebSocketResource::CloseCode::GoingAway, reason);
+  m_packagerWebSocketConnection->Close(Microsoft::React::Networking::IWebSocketResource::CloseCode::GoingAway, reason);
   co_return;
 }
 
 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::Networking::WinRTWebSocketResource>(std::move(certExceptions));
+  m_packagerWebSocketConnection = Microsoft::React::Networking::IWebSocketResource::Make();
 
   m_packagerWebSocketConnection->SetOnError([](const Microsoft::React::Networking::IWebSocketResource::Error &err) {
     facebook::react::tracing::error(err.Message.c_str());

package/Shared/InspectorPackagerConnection.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include <Networking/WinRTWebSocketResource.h>
+#include <Networking/IWebSocketResource.h>
 #include <jsinspector-modern/InspectorInterfaces.h>
 
 namespace Microsoft::ReactNative {
@@ -42,7 +42,7 @@ class InspectorPackagerConnection final : public std::enable_shared_from_this<In
  private:
   std::unordered_map<int32_t, std::unique_ptr<facebook::react::jsinspector_modern::ILocalConnection>>
       m_localConnections;
-  std::shared_ptr<Microsoft::React::Networking::WinRTWebSocketResource> m_packagerWebSocketConnection;
+  std::shared_ptr<Microsoft::React::Networking::IWebSocketResource> m_packagerWebSocketConnection;
   std::shared_ptr<IBundleStatusProvider> m_bundleStatusProvider;
   std::string m_url;
 };

package/Shared/Networking/WinRTWebSocketResource.cpp

@@ -21,16 +21,18 @@
 
 using Microsoft::Common::Utilities::CheckedReinterpretCast;
 
+using Mso::DispatchQueue;
+
 using std::function;
 using std::lock_guard;
 using std::mutex;
-using std::size_t;
 using std::string;
 using std::vector;
 
 using winrt::fire_and_forget;
 using winrt::hresult;
 using winrt::hresult_error;
+using winrt::hstring;
 using winrt::resume_background;
 using winrt::resume_on_signal;
 using winrt::Windows::Foundation::IAsyncAction;
@@ -38,6 +40,7 @@ using winrt::Windows::Foundation::Uri;
 using winrt::Windows::Networking::Sockets::IMessageWebSocket;
 using winrt::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs;
 using winrt::Windows::Networking::Sockets::IWebSocket;
+using winrt::Windows::Networking::Sockets::IWebSocketClosedEventArgs;
 using winrt::Windows::Networking::Sockets::MessageWebSocket;
 using winrt::Windows::Networking::Sockets::SocketMessageType;
 using winrt::Windows::Networking::Sockets::WebSocketClosedEventArgs;
@@ -54,9 +57,9 @@ namespace {
 ///
 /// Implements an awaiter for Mso::DispatchQueue
 ///
-auto resume_in_queue(const Mso::DispatchQueue &queue) noexcept {
+auto resume_in_queue(const DispatchQueue &queue) noexcept {
   struct awaitable {
-    awaitable(const Mso::DispatchQueue &queue) noexcept : m_queue{queue} {}
+    awaitable(const DispatchQueue &queue) noexcept : m_queue{queue} {}
 
     bool await_ready() const noexcept {
       return false;
@@ -79,10 +82,367 @@ auto resume_in_queue(const Mso::DispatchQueue &queue) noexcept {
   return awaitable{queue};
 } // resume_in_queue
 
+DispatchQueue GetCurrentOrSerialQueue() noexcept {
+  auto queue = DispatchQueue::CurrentQueue();
+  if (!queue)
+    queue = DispatchQueue::MakeSerialQueue();
+
+  return queue;
+}
+
 } // namespace
 
 namespace Microsoft::React::Networking {
 
+#pragma region WinRTWebSocketResource2
+
+WinRTWebSocketResource2::WinRTWebSocketResource2(
+    IMessageWebSocket &&socket,
+    IDataWriter &&writer,
+    vector<ChainValidationResult> &&certExceptions,
+    DispatchQueue callingQueue)
+    : m_socket{std::move(socket)},
+      m_writer(std::move(writer)),
+      m_readyState{ReadyState::Connecting},
+      m_connectPerformed{CreateEvent(/*attributes*/ nullptr, /*manual reset*/ true, /*state*/ false, /*name*/ nullptr)},
+      m_callingQueue{callingQueue} {
+  for (const auto &certException : certExceptions) {
+    m_socket.Control().IgnorableServerCertificateErrors().Append(certException);
+  }
+}
+
+// private
+WinRTWebSocketResource2::WinRTWebSocketResource2(
+    IMessageWebSocket &&socket,
+    vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource2(
+          std::move(socket),
+          DataWriter{socket.OutputStream()},
+          std::move(certExceptions),
+          GetCurrentOrSerialQueue()) {}
+
+WinRTWebSocketResource2::WinRTWebSocketResource2(vector<ChainValidationResult> &&certExceptions)
+    : WinRTWebSocketResource2(MessageWebSocket{}, std::move(certExceptions)) {}
+
+WinRTWebSocketResource2::~WinRTWebSocketResource2() noexcept /*override*/
+{}
+
+void WinRTWebSocketResource2::Fail(string &&message, ErrorType type) noexcept {
+  auto self = shared_from_this();
+
+  self->m_backgroundQueue.Post([self, message = std::move(message), type]() {
+    self->m_readyState = ReadyState::Closed;
+    self->m_callingQueue.Post([self, message = std::move(message), type]() {
+      if (self->m_errorHandler) {
+        self->m_errorHandler({std::move(message), type});
+      }
+    });
+  });
+}
+
+void WinRTWebSocketResource2::Fail(hresult &&error, ErrorType type) noexcept {
+  Fail(Utilities::HResultToString(std::move(error)), type);
+}
+
+void WinRTWebSocketResource2::Fail(hresult_error const &error, ErrorType type) noexcept {
+  Fail(Utilities::HResultToString(error), type);
+}
+
+void WinRTWebSocketResource2::OnMessageReceived(
+    IMessageWebSocket const &,
+    IMessageWebSocketMessageReceivedEventArgs const &args) {
+  auto self = shared_from_this();
+  string response;
+
+  IDataReader reader{nullptr};
+  // Use WinRT ABI to avoid throwing exceptions on expected code paths
+  HRESULT hr =
+      reinterpret_cast<ABI::Windows::Networking::Sockets::IMessageWebSocketMessageReceivedEventArgs *>(
+          winrt::get_abi(args))
+          ->GetDataReader(reinterpret_cast<ABI::Windows::Storage::Streams::IDataReader **>(winrt::put_abi(reader)));
+
+  if (FAILED(hr)) {
+    string errorMessage;
+    ErrorType errorType;
+    // See
+    // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-22621#remarks
+    if (hr == WININET_E_CONNECTION_ABORTED) {
+      errorMessage = "[0x80072EFE] Underlying TCP connection suddenly terminated";
+      errorType = ErrorType::Connection;
+      // Note: It is not clear whether all read-related errors should close the socket.
+      Close(CloseCode::BadPayload, std::move(errorMessage));
+    } else {
+      errorMessage = Utilities::HResultToString(hr);
+      errorType = ErrorType::Receive;
+    }
+
+    self->Fail(std::move(errorMessage), errorType);
+
+    return;
+  }
+
+  try {
+    auto len = reader.UnconsumedBufferLength();
+    if (args.MessageType() == SocketMessageType::Utf8) {
+      reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+      vector<uint8_t> data(len);
+      reader.ReadBytes(data);
+
+      response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
+    } else {
+      auto buffer = reader.ReadBuffer(len);
+      auto data = CryptographicBuffer::EncodeToBase64String(buffer);
+
+      response = winrt::to_string(std::wstring_view(data));
+    }
+  } catch (hresult_error const &e) {
+    return self->Fail(e, ErrorType::Receive);
+  }
+
+  // Posting inside try-catch block causes errors.
+  self->m_callingQueue.Post([self, response = std::move(response), messageType = args.MessageType()]() {
+    if (self->m_readHandler) {
+      self->m_readHandler(response.length(), response, messageType == SocketMessageType::Binary);
+    }
+  });
+}
+
+void WinRTWebSocketResource2::OnClosed(IWebSocket const &sender, IWebSocketClosedEventArgs const &args) {
+  auto self = shared_from_this();
+
+  self->m_backgroundQueue.Post([self]() { self->m_readyState = ReadyState::Closed; });
+
+  self->m_callingQueue.Post([self]() {
+    if (self->m_closeHandler) {
+      self->m_closeHandler(self->m_closeCode, self->m_closeReason);
+    }
+  });
+}
+
+fire_and_forget WinRTWebSocketResource2::PerformConnect(Uri &&uri) noexcept {
+  auto self = shared_from_this();
+  auto coUri = std::move(uri);
+
+  co_await resume_in_queue(self->m_backgroundQueue);
+
+  auto async = self->m_socket.ConnectAsync(coUri);
+  co_await lessthrow_await_adapter<IAsyncAction>{async};
+
+  co_await resume_in_queue(self->m_callingQueue);
+
+  auto result = async.ErrorCode();
+
+  try {
+    if (result >= 0) { // Non-failing HRESULT
+      co_await resume_in_queue(self->m_backgroundQueue);
+      self->m_readyState = ReadyState::Open;
+
+      co_await resume_in_queue(self->m_callingQueue);
+      if (self->m_connectHandler) {
+        self->m_connectHandler();
+      }
+    } else {
+      self->Fail(std::move(result), ErrorType::Connection);
+    }
+  } catch (hresult_error const &e) {
+    self->Fail(e, ErrorType::Connection);
+  } catch (std::exception const &e) {
+    self->Fail(e.what(), ErrorType::Connection);
+  }
+
+  SetEvent(self->m_connectPerformed.get());
+}
+
+fire_and_forget WinRTWebSocketResource2::PerformClose() noexcept {
+  auto self = shared_from_this();
+
+  co_await resume_on_signal(self->m_connectPerformed.get());
+
+  co_await resume_in_queue(self->m_backgroundQueue);
+
+  // See https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
+  co_await self->SendPendingMessages();
+
+  try {
+    self->m_socket.Close(static_cast<uint16_t>(m_closeCode), winrt::to_hstring(m_closeReason));
+    self->m_readyState = ReadyState::Closing;
+  } catch (winrt::hresult_invalid_argument const &e) {
+    Fail(e, ErrorType::Close);
+  } catch (hresult_error const &e) {
+    Fail(e, ErrorType::Close);
+  } catch (const std::exception &e) {
+    Fail(e.what(), ErrorType::Close);
+  }
+}
+
+fire_and_forget WinRTWebSocketResource2::PerformWrite(string &&message, bool isBinary) noexcept {
+  auto self = shared_from_this();
+  string coMessage = std::move(message);
+
+  co_await resume_in_queue(self->m_backgroundQueue); // Ensure writes happen sequentially
+  self->m_outgoingMessages.emplace(std::move(coMessage), isBinary);
+
+  co_await resume_on_signal(self->m_connectPerformed.get());
+
+  co_await resume_in_queue(self->m_backgroundQueue);
+
+  co_await self->SendPendingMessages();
+}
+
+IAsyncAction WinRTWebSocketResource2::SendPendingMessages() noexcept {
+  auto self = shared_from_this();
+
+  while (!self->m_outgoingMessages.empty()) {
+    if (self->m_readyState != ReadyState::Open) {
+      co_return;
+    }
+
+    size_t length = 0;
+    string messageLocal;
+    bool isBinaryLocal;
+    try {
+      std::tie(messageLocal, isBinaryLocal) = self->m_outgoingMessages.front();
+      self->m_outgoingMessages.pop();
+      if (isBinaryLocal) {
+        self->m_socket.Control().MessageType(SocketMessageType::Binary);
+
+        auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(messageLocal));
+        if (buffer) {
+          length = buffer.Length();
+          self->m_writer.WriteBuffer(buffer);
+        }
+      } else {
+        self->m_socket.Control().MessageType(SocketMessageType::Utf8);
+
+        length = messageLocal.size();
+        winrt::array_view<const uint8_t> view(
+            CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()),
+            CheckedReinterpretCast<const uint8_t *>(messageLocal.c_str()) + messageLocal.length());
+        self->m_writer.WriteBytes(view);
+      }
+    } catch (hresult_error const &e) { // TODO: Remove after fixing unit tests exceptions.
+      self->Fail(e, ErrorType::Send);
+      co_return;
+    } catch (const std::exception &e) {
+      self->Fail(e.what(), ErrorType::Send);
+      co_return;
+    }
+
+    auto async = self->m_writer.StoreAsync();
+    co_await lessthrow_await_adapter<DataWriterStoreOperation>{async};
+
+    auto result = async.ErrorCode();
+    if (result < 0) {
+      Fail(std::move(result), ErrorType::Send);
+    }
+  }
+}
+
+#pragma region IWebSocketResource
+
+void WinRTWebSocketResource2::Connect(string &&url, const Protocols &protocols, const Options &options) noexcept {
+  // Register MessageReceived BEFORE calling Connect
+  // https://learn.microsoft.com/en-us/uwp/api/windows.networking.sockets.messagewebsocket.messagereceived?view=winrt-22621
+  m_socket.MessageReceived([self = shared_from_this()](
+                               IMessageWebSocket const &sender, IMessageWebSocketMessageReceivedEventArgs const &args) {
+    self->OnMessageReceived(sender, args);
+  });
+
+  m_socket.Closed([self = shared_from_this()](IWebSocket const &sender, IWebSocketClosedEventArgs const &args) {
+    self->OnClosed(sender, args);
+  });
+
+  auto supportedProtocols = m_socket.Control().SupportedProtocols();
+  for (const auto &protocol : protocols) {
+    supportedProtocols.Append(winrt::to_hstring(protocol));
+  }
+
+  Uri uri{nullptr};
+  bool hasOriginHeader{false};
+  try {
+    uri = Uri{winrt::to_hstring(url)};
+
+    for (const auto &header : options) {
+      m_socket.SetRequestHeader(header.first, winrt::to_hstring(header.second));
+      if (boost::iequals(header.first, L"Origin")) {
+        hasOriginHeader = true;
+      }
+    }
+
+    // #12626 - If Origin header is not provided, set to connect endpoint.
+    if (!hasOriginHeader) {
+      auto scheme = uri.SchemeName();
+      auto host = uri.Host();
+      auto port = uri.Port();
+
+      if (scheme == L"ws") {
+        scheme = L"http";
+      } else if (scheme == L"wss") {
+        scheme = L"https";
+      }
+
+      // Only add a port if a port is defined.
+      hstring originPort = port != 0 ? L":" + winrt::to_hstring(port) : L"";
+      auto origin = hstring{scheme + L"://" + host + originPort};
+
+      m_socket.SetRequestHeader(L"Origin", std::move(origin));
+    }
+  } catch (hresult_error const &e) {
+    Fail(e, ErrorType::Connection);
+
+    SetEvent(m_connectPerformed.get());
+
+    return;
+  }
+
+  PerformConnect(std::move(uri));
+}
+
+void WinRTWebSocketResource2::Ping() noexcept {}
+
+void WinRTWebSocketResource2::Send(string &&message) noexcept {
+  PerformWrite(std::move(message), false);
+}
+
+void WinRTWebSocketResource2::SendBinary(string &&base64String) noexcept {
+  PerformWrite(std::move(base64String), true);
+}
+
+void WinRTWebSocketResource2::Close(CloseCode code, const string &reason) noexcept {
+  m_closeCode = code;
+  m_closeReason = reason;
+  PerformClose();
+}
+
+IWebSocketResource::ReadyState WinRTWebSocketResource2::GetReadyState() const noexcept {
+  return m_readyState;
+}
+
+void WinRTWebSocketResource2::SetOnConnect(function<void()> &&handler) noexcept {
+  m_connectHandler = std::move(handler);
+}
+
+void WinRTWebSocketResource2::SetOnPing(function<void()> && /*handler*/) noexcept {}
+
+void WinRTWebSocketResource2::SetOnSend(function<void(size_t)> && /*handler*/) noexcept {}
+
+void WinRTWebSocketResource2::SetOnMessage(function<void(size_t, const string &, bool isBinary)> &&handler) noexcept {
+  m_readHandler = std::move(handler);
+}
+
+void WinRTWebSocketResource2::SetOnClose(function<void(CloseCode, const string &)> &&handler) noexcept {
+  m_closeHandler = std::move(handler);
+}
+
+void WinRTWebSocketResource2::SetOnError(function<void(Error &&)> &&handler) noexcept {
+  m_errorHandler = std::move(handler);
+}
+
+#pragma endregion IWebSocketResource
+
+#pragma endregion WinRTWebSocketResource2
+
+#pragma region Legacy resource
 // private
 WinRTWebSocketResource::WinRTWebSocketResource(
     IMessageWebSocket &&socket,
@@ -331,7 +691,7 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
         response = string(CheckedReinterpretCast<char *>(data.data()), data.size());
       } else {
         auto buffer = reader.ReadBuffer(len);
-        winrt::hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
+        hstring data = CryptographicBuffer::EncodeToBase64String(buffer);
 
         response = winrt::to_string(std::wstring_view(data));
       }
@@ -360,7 +720,7 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
     }
   }
 
-  winrt::Windows::Foundation::Collections::IVector<winrt::hstring> supportedProtocols =
+  winrt::Windows::Foundation::Collections::IVector<hstring> supportedProtocols =
       m_socket.Control().SupportedProtocols();
   for (const auto &protocol : protocols) {
     supportedProtocols.Append(winrt::to_hstring(protocol));
@@ -383,8 +743,8 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
       }
 
       // Only add a port if a port is defined
-      winrt::hstring originPort = port != 0 ? L":" + winrt::to_hstring(port) : L"";
-      auto origin = winrt::hstring{scheme + L"://" + host + originPort};
+      hstring originPort = port != 0 ? L":" + winrt::to_hstring(port) : L"";
+      auto origin = hstring{scheme + L"://" + host + originPort};
 
       m_socket.SetRequestHeader(L"Origin", std::move(origin));
     }
@@ -461,4 +821,6 @@ void WinRTWebSocketResource::SetOnError(function<void(Error &&)> &&handler) noex
 
 #pragma endregion IWebSocketResource
 
+#pragma endregion Legacy resource
+
 } // namespace Microsoft::React::Networking