react-native-windows 0.84.0-preview.9 → 0.85.0-preview.1

package/Shared/DevSupportManager.cpp

@@ -33,7 +33,6 @@
 #include <cxxreact/MessageQueueThread.h>
 #pragma warning(pop)
 
-#include <future>
 #include <mutex>
 
 #include <AppModel.h>
@@ -47,61 +46,59 @@ using namespace facebook::react;
 
 namespace Microsoft::ReactNative {
 
-std::future<std::pair<std::string, bool>> GetJavaScriptFromServerAsync(const std::string &url) {
-  winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter filter;
-  filter.CacheControl().ReadBehavior(winrt::Windows::Web::Http::Filters::HttpCacheReadBehavior::NoCache);
-  winrt::Windows::Web::Http::HttpClient httpClient(filter);
-  winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IBuffer> GetJavaScriptFromServerAsync(
+    const std::string &url) {
+  try {
+    winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter filter;
+    filter.CacheControl().ReadBehavior(winrt::Windows::Web::Http::Filters::HttpCacheReadBehavior::NoCache);
+    winrt::Windows::Web::Http::HttpClient httpClient(filter);
+    winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
 
-  co_await winrt::resume_background();
+    co_await winrt::resume_background();
 
-  winrt::Windows::Web::Http::HttpRequestMessage request(winrt::Windows::Web::Http::HttpMethod::Get(), uri);
-  auto asyncRequest = httpClient.SendRequestAsync(request);
+    winrt::Windows::Web::Http::HttpRequestMessage request(winrt::Windows::Web::Http::HttpMethod::Get(), uri);
+    auto asyncRequest = httpClient.SendRequestAsync(request);
 #ifdef DEFAULT_CPPWINRT_EXCEPTIONS
-  try {
     winrt::Windows::Web::Http::HttpResponseMessage response = co_await asyncRequest;
-  } catch (winrt::hresult_error const &e) {
-    co_return std::make_pair(
-        Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()).c_str(), false);
-  }
 #else
-  co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
-      winrt::Windows::Web::Http::HttpResponseMessage,
-      winrt::Windows::Web::Http::HttpProgress>>{asyncRequest};
-
-  HRESULT hr = asyncRequest.ErrorCode();
-  if (FAILED(hr)) {
-    std::string error;
-    if (hr == WININET_E_CANNOT_CONNECT) {
-      error = fmt::format("A connection with the server {} could not be established.\n\nIs the packager running?", url);
-    } else {
-      error = fmt::format("Error 0x{:x} downloading {}.", static_cast<int>(asyncRequest.ErrorCode()), url);
+    co_await lessthrow_await_adapter<winrt::Windows::Foundation::IAsyncOperationWithProgress<
+        winrt::Windows::Web::Http::HttpResponseMessage,
+        winrt::Windows::Web::Http::HttpProgress>>{asyncRequest};
+
+    HRESULT hr = asyncRequest.ErrorCode();
+    if (FAILED(hr)) {
+      std::string error;
+      if (hr == WININET_E_CANNOT_CONNECT) {
+        error =
+            fmt::format("A connection with the server {} could not be established.\n\nIs the packager running?", url);
+      } else {
+        error = fmt::format("Error 0x{:x} downloading {}.", static_cast<int>(asyncRequest.ErrorCode()), url);
+      }
+      throw winrt::hresult_error(E_FAIL, winrt::to_hstring(error));
     }
-    co_return std::make_pair(error, false);
-  }
 
-  winrt::Windows::Web::Http::HttpResponseMessage response = asyncRequest.GetResults();
+    winrt::Windows::Web::Http::HttpResponseMessage response = asyncRequest.GetResults();
 #endif
 
-  winrt::Windows::Storage::Streams::IBuffer buffer = co_await response.Content().ReadAsBufferAsync();
-  auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
-
-  reader.UnicodeEncoding(winrt::Windows::Storage::Streams::UnicodeEncoding::Utf8);
-  uint32_t len = reader.UnconsumedBufferLength();
-  std::string result;
-  if (len > 0 || response.IsSuccessStatusCode()) {
-    std::string data;
-    data.resize(len);
-    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 {
-    result = fmt::format("HTTP Error {} downloading {}.", static_cast<int>(response.StatusCode()), url);
-  }
+    winrt::Windows::Storage::Streams::IBuffer buffer = co_await response.Content().ReadAsBufferAsync();
+
+    if (!response.IsSuccessStatusCode()) {
+      std::string error;
+      if (buffer.Length() > 0) {
+        auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
+        error.resize(buffer.Length());
+        auto buf = reinterpret_cast<uint8_t *>(error.data());
+        reader.ReadBytes(winrt::array_view(buf, buf + buffer.Length()));
+      } else {
+        error = fmt::format("HTTP Error {} downloading {}.", static_cast<int>(response.StatusCode()), url);
+      }
+      throw winrt::hresult_error(E_FAIL, winrt::to_hstring(error));
+    }
 
-  co_return std::make_pair(std::move(result), response.IsSuccessStatusCode());
+    co_return buffer;
+  } catch (winrt::hresult_error const &) {
+    throw;
+  }
 }
 
 void LaunchDevTools(const facebook::react::DevSettings &settings) {
@@ -185,7 +182,8 @@ std::string GetPackageName(const std::string &bundleAppId) {
   return packageName;
 }
 
-std::future<winrt::Windows::Web::Http::HttpStatusCode> PollForLiveReload(const std::string &url) {
+winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Web::Http::HttpStatusCode> PollForLiveReload(
+    const std::string &url) {
   winrt::Windows::Web::Http::HttpClient httpClient;
   winrt::Windows::Foundation::Uri uri(Microsoft::Common::Unicode::Utf8ToUtf16(url));
   httpClient.DefaultRequestHeaders().Connection().TryParseAdd(L"keep-alive");
@@ -299,7 +297,16 @@ std::pair<std::string, bool> GetJavaScriptFromServer(
       inlineSourceMap,
       hermesBytecodeVersion);
   try {
-    return GetJavaScriptFromServerAsync(bundleUrl).get();
+    auto buffer = GetJavaScriptFromServerAsync(bundleUrl).get();
+    std::string result(buffer.Length(), '\0');
+    if (!result.empty()) {
+      auto reader = winrt::Windows::Storage::Streams::DataReader::FromBuffer(buffer);
+      reader.ReadBytes(winrt::array_view<uint8_t>{
+          reinterpret_cast<uint8_t *>(&result[0]), reinterpret_cast<uint8_t *>(&result[result.length()])});
+    }
+    return std::make_pair(std::move(result), true);
+  } catch (std::exception const &e) {
+    return std::make_pair(std::string{"Error: "} + e.what(), false);
   } catch (winrt::hresult_error const &e) {
     return std::make_pair(
         "Error: " + Microsoft::Common::Unicode::Utf16ToUtf8(e.message().c_str(), e.message().size()), false);

package/Shared/DevSupportManager.h

@@ -10,7 +10,6 @@
 #include <winrt/Windows.Networking.Sockets.h>
 #include <atomic>
 #include <functional>
-#include <future>
 #include <memory>
 #include <string>
 

package/Shared/Modules/IWebSocketModuleContentHandler.h

@@ -18,11 +18,26 @@ namespace Microsoft::React {
 struct IWebSocketModuleContentHandler {
   virtual ~IWebSocketModuleContentHandler() noexcept {}
 
+  /// Returns true if this handler should process messages for the given socket.
+  virtual bool CanHandleSocket(int64_t socketId) noexcept = 0;
+
   virtual void ProcessMessage(std::string &&message, winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
 
   virtual void ProcessMessage(
       std::vector<uint8_t> &&message,
       winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
+
+  /// Check CanHandleSocket() then ProcessMessage() in one call.
+  /// Returns true if the message was handled.
+  virtual bool TryProcessMessage(
+      int64_t socketId,
+      std::string &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
+
+  virtual bool TryProcessMessage(
+      int64_t socketId,
+      std::vector<uint8_t> &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept = 0;
 };
 
 } // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.cpp

@@ -83,6 +83,7 @@ shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id,
     if (auto prop = propBag.Get(BlobModuleContentHandlerPropertyId()))
       contentHandler = prop.Value().lock();
 
+    bool handled = false;
     if (contentHandler) {
       if (isBinary) {
         auto buffer = CryptographicBuffer::DecodeFromBase64String(winrt::to_hstring(message));
@@ -90,11 +91,15 @@ shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id,
         CryptographicBuffer::CopyToByteArray(buffer, arr);
         auto data = vector<uint8_t>(arr.begin(), arr.end());
 
-        contentHandler->ProcessMessage(std::move(data), args);
+        handled = contentHandler->TryProcessMessage(id, std::move(data), args);
       } else {
-        contentHandler->ProcessMessage(string{message}, args);
+        handled = contentHandler->TryProcessMessage(id, string{message}, args);
       }
-    } else {
+    }
+    // When the content handler processes the message, it takes ownership of the
+    // payload and populates args itself (e.g. as a blob reference), so we only
+    // fall back to setting args["data"] when no handler claimed the message.
+    if (!handled) {
       args["data"] = message;
     }
 

package/Shared/Networking/DefaultBlobResource.cpp

@@ -221,6 +221,11 @@ BlobWebSocketModuleContentHandler::BlobWebSocketModuleContentHandler(shared_ptr<
 
 #pragma region IWebSocketModuleContentHandler
 
+bool BlobWebSocketModuleContentHandler::CanHandleSocket(int64_t socketId) noexcept /*override*/ {
+  scoped_lock lock{m_mutex};
+  return m_socketIds.find(socketId) != m_socketIds.end();
+}
+
 void BlobWebSocketModuleContentHandler::ProcessMessage(
     string &&message,
     msrn::JSValueObject &params) noexcept /*override*/
@@ -241,6 +246,38 @@ void BlobWebSocketModuleContentHandler::ProcessMessage(
   params[blobKeys.Type] = blobKeys.Blob;
 }
 
+bool BlobWebSocketModuleContentHandler::TryProcessMessage(
+    int64_t socketId,
+    string &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  scoped_lock lock{m_mutex};
+  if (m_socketIds.find(socketId) == m_socketIds.end())
+    return false;
+
+  params[blobKeys.Data] = std::move(message);
+  return true;
+}
+
+bool BlobWebSocketModuleContentHandler::TryProcessMessage(
+    int64_t socketId,
+    vector<uint8_t> &&message,
+    msrn::JSValueObject &params) noexcept /*override*/
+{
+  scoped_lock lock{m_mutex};
+  if (m_socketIds.find(socketId) == m_socketIds.end())
+    return false;
+
+  auto blob = msrn::JSValueObject{
+      {blobKeys.Offset, 0},
+      {blobKeys.Size, message.size()},
+      {blobKeys.BlobId, m_blobPersistor->StoreMessage(std::move(message))}};
+
+  params[blobKeys.Data] = std::move(blob);
+  params[blobKeys.Type] = blobKeys.Blob;
+  return true;
+}
+
 #pragma endregion IWebSocketModuleContentHandler
 
 void BlobWebSocketModuleContentHandler::Register(int64_t socketID) noexcept {

package/Shared/Networking/DefaultBlobResource.h

@@ -51,11 +51,23 @@ class BlobWebSocketModuleContentHandler final : public IWebSocketModuleContentHa
 
 #pragma region IWebSocketModuleContentHandler
 
+  bool CanHandleSocket(int64_t socketId) noexcept override;
+
   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;
 
+  bool TryProcessMessage(
+      int64_t socketId,
+      std::string &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
+
+  bool TryProcessMessage(
+      int64_t socketId,
+      std::vector<uint8_t> &&message,
+      winrt::Microsoft::ReactNative::JSValueObject &params) noexcept override;
+
 #pragma endregion IWebSocketModuleContentHandler
 
   void Register(int64_t socketID) noexcept;