react-native-windows 0.67.8 → 0.67.9

package/CHANGELOG.json

@@ -1,6 +1,48 @@
 {
   "name": "react-native-windows",
   "entries": [
+    {
+      "date": "Mon, 02 May 2022 15:10:43 GMT",
+      "tag": "react-native-windows_v0.67.9",
+      "version": "0.67.9",
+      "comments": {
+        "patch": [
+          {
+            "author": "53799235+ZihanChen-MSFT@users.noreply.github.com",
+            "package": "react-native-windows",
+            "commit": "9458dad1646fa2a8a5afea7383133eeca144fb88",
+            "comment": "Fix clang-check errors in NativeModules.h"
+          },
+          {
+            "author": "vmorozov@microsoft.com",
+            "package": "react-native-windows",
+            "commit": "38c0547235927e51c08bd17b08b2f6be878fd0a5",
+            "comment": "Fix JSI for Node-API and update V8 to 0.65.11"
+          },
+          {
+            "author": "julio.rocha@microsoft.com",
+            "package": "react-native-windows",
+            "commit": "e3ef52d578991181c00a6487c902ce4c31cc702a",
+            "comment": "Handle abrupt WebSocket connection interruption (#9829)"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 25 Apr 2022 15:11:36 GMT",
+      "tag": "react-native-windows_v0.67.8",
+      "version": "0.67.8",
+      "comments": {
+        "patch": [
+          {
+            "author": "vmorozov@microsoft.com",
+            "package": "react-native-windows",
+            "commit": "not available",
+            "comment": "Fix Sequential DispatchQueue deadlock on shutdown"
+          }
+        ]
+      }
+    },
     {
       "date": "Mon, 25 Apr 2022 15:11:22 GMT",
       "tag": "react-native-windows_v0.67.8",

package/CHANGELOG.md

@@ -1,17 +1,35 @@
 # Change Log - react-native-windows
 
-This log was last generated on Mon, 25 Apr 2022 15:11:22 GMT and should not be manually modified.
+This log was last generated on Mon, 02 May 2022 15:10:43 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## 0.67.8
+## 0.67.9
 
-Mon, 25 Apr 2022 15:11:22 GMT
+Mon, 02 May 2022 15:10:43 GMT
 
 ### Patches
 
-- Fix Sequential DispatchQueue deadlock on shutdown (vmorozov@microsoft.com)
+- Fix clang-check errors in NativeModules.h (53799235+ZihanChen-MSFT@users.noreply.github.com)
+- Fix JSI for Node-API and update V8 to 0.65.11 (vmorozov@microsoft.com)
+- Handle abrupt WebSocket connection interruption (#9829) (julio.rocha@microsoft.com)
 
+## 0.67.8
+
+Mon, 25 Apr 2022 15:11:36 GMT
+
+### Patches
+
+- Fix Sequential DispatchQueue deadlock on shutdown (vmorozov@microsoft.com)
+
+## 0.67.8
+
+Mon, 25 Apr 2022 15:11:22 GMT
+
+### Patches
+
+- Fix Sequential DispatchQueue deadlock on shutdown (vmorozov@microsoft.com)
+
 ## 0.67.7
 
 Mon, 04 Apr 2022 15:13:28 GMT

package/Microsoft.ReactNative/Base/CoreNativeModules.cpp

@@ -13,7 +13,6 @@
 #include <Modules/ClipboardModule.h>
 #include <Modules/LinkingManagerModule.h>
 #include <Modules/NativeUIManager.h>
-#include <Modules/NetworkingModule.h>
 #include <Modules/PaperUIManagerModule.h>
 #include <Threading/MessageQueueThreadFactory.h>
 
@@ -50,9 +49,7 @@ std::vector<facebook::react::NativeModuleDescription> GetCoreModules(
   std::vector<facebook::react::NativeModuleDescription> modules;
 
   modules.emplace_back(
-      Microsoft::React::NetworkingModule::Name,
-      []() { return std::make_unique<Microsoft::React::NetworkingModule>(); },
-      jsMessageQueue);
+      "Networking", []() { return Microsoft::React::CreateHttpModule(); }, jsMessageQueue);
 
   modules.emplace_back(
       "Timing",

package/Microsoft.ReactNative/packages.config

@@ -8,5 +8,5 @@
   <package id="Microsoft.Windows.CppWinRT" version="2.0.210312.4" targetFramework="native" />
   <package id="Microsoft.WinUI" version="3.0.0-preview4.210210.4" targetFramework="native" />
   <package id="ReactNative.Hermes.Windows" version="0.10.0-ms.1" targetFramework="native" />
-  <!-- package id="ReactNative.V8Jsi.Windows.UWP" version="0.65.5" targetFramework="native" / -->
+  <!-- package id="ReactNative.V8Jsi.Windows.UWP" version="0.65.11" targetFramework="native" / -->
 </packages>

package/Microsoft.ReactNative.Cxx/JSI/NodeApiJsiRuntime.cpp

@@ -190,7 +190,7 @@ struct NapiJsiRuntime : facebook::jsi::Runtime {
   facebook::jsi::Function createFunctionFromHostFunction(
       const facebook::jsi::PropNameID &name,
       unsigned int paramCount,
-      facebook::jsi::HostFunctionType type) override;
+      facebook::jsi::HostFunctionType func) override;
   facebook::jsi::Value call(
       const facebook::jsi::Function &func,
       const facebook::jsi::Value &jsThis,
@@ -475,7 +475,7 @@ struct NapiJsiRuntime : facebook::jsi::Runtime {
   void SetProperty(napi_value object, napi_value propertyId, napi_value value, napi_property_attributes attrs) const;
   napi_value CreateArray(size_t length) const;
   void SetElement(napi_value array, uint32_t index, napi_value value) const;
-  static napi_value JsiHostFunctionCallback(napi_env env, napi_callback_info info) noexcept;
+  static napi_value __cdecl JsiHostFunctionCallback(napi_env env, napi_callback_info info) noexcept;
   napi_value CreateExternalFunction(napi_value name, int32_t paramCount, napi_callback callback, void *callbackData);
   napi_value CreateExternalObject(void *data, napi_finalize finalizeCallback) const;
   template <typename T>
@@ -1702,7 +1702,7 @@ void NapiJsiRuntime::SetElement(napi_value array, uint32_t index, napi_value val
 }
 
 // The NAPI external function callback used for the JSI host function implementation.
-/*static*/ napi_value NapiJsiRuntime::JsiHostFunctionCallback(napi_env env, napi_callback_info info) noexcept {
+/*static*/ napi_value __cdecl NapiJsiRuntime::JsiHostFunctionCallback(napi_env env, napi_callback_info info) noexcept {
   HostFunctionWrapper *hostFuncWrapper{};
   size_t argc{};
   CHECK_NAPI_ELSE_CRASH(
@@ -1750,15 +1750,11 @@ napi_value NapiJsiRuntime::CreateExternalObject(void *data, napi_finalize finali
 // Wraps up std::unique_ptr as an external object.
 template <typename T>
 napi_value NapiJsiRuntime::CreateExternalObject(unique_ptr<T> &&data) const {
-  napi_value object =
-      CreateExternalObject(data.get(), [](napi_env /*env*/, void *dataToDestroy, void * /*finalizerHint*/) {
-        // We wrap dataToDestroy in a unique_ptr to avoid calling delete explicitly.
-        if (std::is_array<T>::value) {
-          delete[] static_cast<T *>(dataToDestroy);
-        } else {
-          delete static_cast<T *>(dataToDestroy);
-        }
-      });
+  napi_finalize finalize = [](napi_env /*env*/, void *dataToDestroy, void * /*finalizerHint*/) {
+    // We wrap dataToDestroy in a unique_ptr to avoid calling delete explicitly.
+    unique_ptr<T> dataDeleter{static_cast<T *>(dataToDestroy)};
+  };
+  napi_value object = CreateExternalObject(data.get(), finalize);
 
   // We only call data.release() after the CreateExternalObject succeeds.
   // Otherwise, when CreateExternalObject fails and an exception is thrown,
@@ -1807,7 +1803,7 @@ napi_value NapiJsiRuntime::GetHostObjectProxyHandler() {
 // Sets Proxy trap method as a pointer to NapiJsiRuntime instance method.
 template <napi_value (NapiJsiRuntime::*trapMethod)(span<napi_value>), size_t argCount>
 void NapiJsiRuntime::SetProxyTrap(napi_value handler, napi_value propertyName) {
-  auto proxyTrap = [](napi_env env, napi_callback_info info) noexcept {
+  napi_callback proxyTrap = [](napi_env env, napi_callback_info info) noexcept {
     NapiJsiRuntime *runtime{};
     napi_value args[argCount]{};
     size_t actualArgCount{argCount};

package/Microsoft.ReactNative.Cxx/JSI/NodeApiJsiRuntime.h

@@ -2,6 +2,8 @@
 // Licensed under the MIT License.
 
 #pragma once
+#ifndef MICROSOFT_REACTNATIVE_JSI_NODEAPIJSIRUNTIME
+#define MICROSOFT_REACTNATIVE_JSI_NODEAPIJSIRUNTIME
 
 // JSI
 #include <js_native_ext_api.h>
@@ -19,3 +21,5 @@ namespace Microsoft::JSI {
 std::unique_ptr<facebook::jsi::Runtime> __cdecl MakeNodeApiJsiRuntime(napi_env env) noexcept;
 
 } // namespace Microsoft::JSI
+
+#endif // MICROSOFT_REACTNATIVE_JSI_NODEAPIJSIRUNTIME

package/Microsoft.ReactNative.Cxx/NativeModules.h

@@ -1091,7 +1091,7 @@ template <class TModule, int I, class TMethodSpec>
 struct ReactMethodVerifier {
   static constexpr bool Verify() noexcept {
     ReactMethodVerifier verifier{};
-    ReactMemberInfoIterator<TModule>{}.GetMemberInfo<I>(verifier);
+    ReactMemberInfoIterator<TModule>{}.template GetMemberInfo<I>(verifier);
     return verifier.m_result;
   }
 
@@ -1109,7 +1109,7 @@ template <class TModule, int I, class TMethodSpec>
 struct ReactSyncMethodVerifier {
   static constexpr bool Verify() noexcept {
     ReactSyncMethodVerifier verifier{};
-    ReactMemberInfoIterator<TModule>{}.GetMemberInfo<I>(verifier);
+    ReactMemberInfoIterator<TModule>{}.template GetMemberInfo<I>(verifier);
     return verifier.m_result;
   }
 

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,10 +10,10 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.67.8</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.67.9</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>67</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>8</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>9</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
   </PropertyGroup>
 </Project>

package/PropertySheets/JSEngine.props

@@ -16,7 +16,7 @@
     <EnableDevServerHBCBundles Condition="'$(EnableDevServerHBCBundles)' == ''">false</EnableDevServerHBCBundles>
 
     <UseV8 Condition="'$(UseV8)' == ''">false</UseV8>
-    <V8Version Condition="'$(V8Version)' == ''">0.65.5</V8Version>
+    <V8Version Condition="'$(V8Version)' == ''">0.65.11</V8Version>
     <V8PackageName>ReactNative.V8Jsi.Windows</V8PackageName>
     <V8PackageName Condition="'$(V8AppPlatform)' != 'win32'">$(V8PackageName).UWP</V8PackageName>
     <V8Package>$(SolutionDir)packages\$(V8PackageName).$(V8Version)</V8Package>

package/Shared/CreateModules.h

@@ -32,6 +32,10 @@ extern std::unique_ptr<facebook::xplat::module::CxxModule> CreateAsyncStorageMod
 
 namespace Microsoft::React {
 
+extern const char *GetHttpModuleName() noexcept;
+extern std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule() noexcept;
+
+extern const char *GetWebSocketModuleName() noexcept;
 extern std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule() noexcept;
 
 } // namespace Microsoft::React

package/Shared/IHttpResource.h

@@ -3,32 +3,51 @@
 
 #pragma once
 
-#include <Folly/dynamic.h>
+// Standard Library
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
 
 namespace Microsoft::React {
 
 struct IHttpResource {
-  typedef std::map<std::string, std::string> Headers;
+  typedef std::unordered_map<std::string, std::string> Headers;
 
-  static std::unique_ptr<IHttpResource> Make() noexcept;
+  struct BodyData {
+    enum class Type : size_t { Empty, String, Base64, Uri, Form } Type = Type::Empty;
+    std::string Data;
+  };
+
+  struct Response {
+    int64_t StatusCode;
+    Headers Headers;
+    std::string Url;
+  };
+
+  static std::shared_ptr<IHttpResource> Make() noexcept;
 
   virtual ~IHttpResource() noexcept {}
 
   virtual void SendRequest(
-      const std::string &method,
-      const std::string &url,
-      const Headers &headers,
-      folly::dynamic bodyData, // ISS:2365799 - Make non-folly.
-      const std::string &responseType,
+      std::string &&method,
+      std::string &&url,
+      Headers &&headers,
+      BodyData &&bodyData,
+      std::string &&responseType,
       bool useIncrementalUpdates,
-      std::int64_t timeout,
+      int64_t timeout,
+      bool withCredentials,
       std::function<void(int64_t)> &&callback) noexcept = 0;
-  virtual void AbortRequest() noexcept = 0;
+  virtual void AbortRequest(int64_t requestId) noexcept = 0;
+
   virtual void ClearCookies() noexcept = 0;
 
-  virtual void SetOnRequest(std::function<void()> &&handler) noexcept = 0;
-  virtual void SetOnResponse(std::function<void(const std::string &)> &&handler) noexcept = 0;
-  virtual void SetOnError(std::function<void(const std::string &)> &&handler) noexcept = 0;
+  virtual void SetOnRequest(std::function<void(int64_t requestId)> &&handler) noexcept = 0; // TODO: Keep???
+  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

package/Shared/IWebSocketResource.h

@@ -71,7 +71,7 @@ struct IWebSocketResource {
 
   struct Error {
     std::string Message;
-    const ErrorType Type;
+    ErrorType Type;
   };
 
 #pragma endregion Inner types

package/Shared/JSI/NapiJsiV8RuntimeHolder.h

@@ -22,7 +22,7 @@ class NapiJsiV8RuntimeHolder : public Microsoft::JSI::RuntimeHolderLazyInit {
       std::unique_ptr<facebook::jsi::PreparedScriptStore> &&preparedScriptStore) noexcept;
 
  private:
-  static void ScheduleTaskCallback(
+  static void __cdecl ScheduleTaskCallback(
       napi_env env,
       napi_ext_task_callback taskCb,
       void *taskData,

package/Shared/Modules/HttpModule.cpp

@@ -0,0 +1,198 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "HttpModule.h"
+
+// React Native
+#include <cxxreact/Instance.h>
+#include <cxxreact/JsArgumentHelpers.h>
+
+using facebook::react::Instance;
+using folly::dynamic;
+using std::shared_ptr;
+using std::string;
+using std::weak_ptr;
+
+namespace {
+
+using Microsoft::React::IHttpResource;
+
+constexpr char moduleName[] = "Networking";
+
+static void SendEvent(weak_ptr<Instance> weakReactInstance, string &&eventName, dynamic &&args) {
+  if (auto instance = weakReactInstance.lock()) {
+    instance->callJSFunction("RCTDeviceEventEmitter", "emit", dynamic::array(std::move(eventName), std::move(args)));
+  }
+}
+
+static shared_ptr<IHttpResource> CreateHttpResource(weak_ptr<Instance> weakReactInstance) {
+  auto resource = IHttpResource::Make();
+
+  resource->SetOnResponse([weakReactInstance](int64_t requestId, IHttpResource::Response &&response) {
+    dynamic headers = dynamic::object();
+    for (auto &header : response.Headers) {
+      headers[header.first] = header.second;
+    }
+
+    // TODO: Test response content.
+    dynamic args = dynamic::array(requestId, response.StatusCode, headers, response.Url);
+
+    SendEvent(weakReactInstance, "didReceiveNetworkResponse", std::move(args));
+  });
+
+  resource->SetOnData([weakReactInstance](int64_t requestId, std::string &&responseData) {
+    dynamic args = dynamic::array(requestId, std::move(responseData));
+
+    SendEvent(weakReactInstance, "didReceiveNetworkData", std::move(args));
+
+    // TODO: Move into separate method IF not executed right after onData()
+    SendEvent(weakReactInstance, "didCompleteNetworkResponse", dynamic::array(requestId));
+  });
+
+  resource->SetOnError([weakReactInstance](int64_t requestId, string &&message) {
+    dynamic args = dynamic::array(requestId, std::move(message));
+    // TODO: isTimeout errorArgs.push_back(true);
+
+    SendEvent(weakReactInstance, "didCompleteNetworkResponse", std::move(args));
+  });
+
+  return resource;
+}
+
+} // namespace
+
+namespace Microsoft::React {
+
+HttpModule::HttpModule() noexcept : m_holder{std::make_shared<ModuleHolder>()} {
+  m_holder->Module = this;
+}
+
+HttpModule::~HttpModule() noexcept /*override*/ {
+  m_holder->Module = nullptr;
+}
+
+#pragma region CxxModule
+
+string HttpModule::getName() /*override*/ {
+  return moduleName;
+}
+
+std::map<string, dynamic> HttpModule::getConstants() {
+  return {};
+}
+
+// clang-format off
+std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods() {
+
+  auto weakHolder = weak_ptr<ModuleHolder>(m_holder);
+  auto holder = weakHolder.lock();
+  auto weakReactInstance = weak_ptr<Instance>(holder->Module->getInstance());
+
+  return
+  {
+    {
+      "sendRequest",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args, Callback cxxCallback)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder) {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        {
+          IHttpResource::BodyData bodyData;
+          auto params = facebook::xplat::jsArgAsObject(args, 0);
+          auto data = params["data"];
+          auto stringData = data["string"];
+          if (!stringData.empty())
+          {
+            bodyData = {IHttpResource::BodyData::Type::String, stringData.getString()};
+          }
+          else
+          {
+            auto base64Data = data["base64"];
+            if (!base64Data.empty())
+            {
+              bodyData = {IHttpResource::BodyData::Type::Base64, base64Data.getString()};
+            }
+            else
+            {
+              auto uriData = data["uri"];
+              if (!uriData.empty())
+              {
+                bodyData = {IHttpResource::BodyData::Type::Uri, uriData.getString()};
+              }
+            }
+          }
+          //TODO: Support FORM data
+
+          IHttpResource::Headers headers;
+          for (auto& header : params["headers"].items()) {
+            headers.emplace(header.first.getString(), header.second.getString());
+          }
+
+          resource->SendRequest(
+            params["method"].asString(),
+            params["url"].asString(),
+            std::move(headers),
+            std::move(bodyData),
+            params["responseType"].asString(),
+            params["incrementalUpdates"].asBool(),
+            static_cast<int64_t>(params["timeout"].asDouble()),
+            false,//withCredentials,
+            [cxxCallback = std::move(cxxCallback)](int64_t requestId) {
+              cxxCallback({requestId});
+            }
+          );
+        } // If resource available
+      }
+    },
+    {
+      "abortRequest",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder)
+        {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        {
+          resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
+        }
+      }
+    },
+    {
+      "clearCookies",
+      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+      {
+        auto holder = weakHolder.lock();
+        if (!holder)
+        {
+          return;
+        }
+
+        auto resource = holder->Module->m_resource;
+        if (resource || (resource = CreateHttpResource(holder->Module->getInstance())))
+        {
+          resource->ClearCookies();
+        }
+      }
+    }
+  };
+}
+// clang-format on
+
+#pragma endregion CxxModule
+
+/*extern*/ const char *GetHttpModuleName() noexcept {
+  return moduleName;
+}
+
+} // namespace Microsoft::React

package/Shared/Modules/HttpModule.h

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "IHttpResource.h"
+
+// React Native
+#include <cxxreact/CxxModule.h>
+
+namespace Microsoft::React {
+
+///
+/// Realizes <c>NativeModules</c> projection.
+/// <remarks>See src\Libraries\Network\RCTNetworkingWinShared.js</remarks>
+///
+class HttpModule : public facebook::xplat::module::CxxModule {
+ public:
+  enum MethodId { SendRequest = 0, AbortRequest = 1, ClearCookies = 2, LAST = ClearCookies };
+
+  HttpModule() noexcept;
+
+  ~HttpModule() noexcept override;
+
+#pragma region CxxModule
+
+  /// <summary>
+  /// <see cref="facebook::xplat::module::CxxModule::getName" />
+  /// </summary>
+  std::string getName() override;
+
+  /// <summary>
+  /// <see cref="facebook::xplat::module::CxxModule::getConstants" />
+  /// </summary>
+  std::map<std::string, folly::dynamic> getConstants() override;
+
+  /// <summary>
+  /// <see cref="facebook::xplat::module::CxxModule::getMethods" />
+  /// </summary>
+  /// <remarks>See See react-native/Libraries/WebSocket/WebSocket.js</remarks>
+  std::vector<Method> getMethods() override;
+
+#pragma endregion CxxModule
+
+ private:
+  struct ModuleHolder {
+    HttpModule *Module{nullptr};
+  };
+
+  std::shared_ptr<IHttpResource> m_resource;
+  std::shared_ptr<ModuleHolder> m_holder;
+};
+} // namespace Microsoft::React

package/Shared/Modules/WebSocketModule.cpp

@@ -246,6 +246,10 @@ std::vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMeth
 } // getMethods
 // clang-format on
 
+/*extern*/ const char *GetWebSocketModuleName() noexcept {
+  return moduleName;
+}
+
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateWebSocketModule() noexcept {
   return std::make_unique<WebSocketModule>();
 }

package/Shared/OInstance.cpp

@@ -26,6 +26,8 @@
 #include <cxxreact/ModuleRegistry.h>
 
 #include <Modules/ExceptionsManagerModule.h>
+#include <Modules/HttpModule.h>
+#include <Modules/NetworkingModule.h>
 #include <Modules/PlatformConstantsModule.h>
 #include <Modules/SourceCodeModule.h>
 #include <Modules/StatusBarManagerModule.h>
@@ -146,6 +148,18 @@ using namespace Microsoft::JSI;
 
 using std::make_shared;
 
+namespace Microsoft::React {
+
+/*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule() noexcept {
+  if (GetRuntimeOptionBool("Http.UseMonolithicModule")) {
+    return std::make_unique<NetworkingModule>();
+  } else {
+    return std::make_unique<HttpModule>();
+  }
+}
+
+} // namespace Microsoft::React
+
 namespace facebook {
 namespace react {
 
@@ -613,7 +627,13 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
 
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
-      "WebSocketModule",
+      Microsoft::React::GetHttpModuleName(),
+      [nativeQueue]() -> std::unique_ptr<xplat::module::CxxModule> { return Microsoft::React::CreateHttpModule(); },
+      nativeQueue));
+
+  modules.push_back(std::make_unique<CxxNativeModule>(
+      m_innerInstance,
+      Microsoft::React::GetWebSocketModuleName(),
       [nativeQueue]() -> std::unique_ptr<xplat::module::CxxModule> {
         return Microsoft::React::CreateWebSocketModule();
       },

package/Shared/Shared.vcxitems

@@ -46,6 +46,7 @@
       <ExcludedFromBuild Condition="'$(ApplicationType)' == ''">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\ExceptionsManagerModule.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\HttpModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\I18nModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\PlatformConstantsModule.cpp" />
@@ -61,9 +62,11 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)tracing\tracing.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)TurboModuleManager.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Utils.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Utils\WinRTConversions.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)V8JSIRuntimeHolder.cpp">
       <ExcludedFromBuild Condition="'$(UseV8)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)WinRTHttpResource.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)WinRTWebSocketResource.cpp" />
   </ItemGroup>
   <ItemGroup>
@@ -83,6 +86,7 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\NapiJsiV8RuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\RuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)JSI\ScriptStore.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\HttpModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)RuntimeOptions.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\AsyncStorageModuleWin32.h" />
@@ -130,8 +134,10 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)TurboModuleRegistry.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Utils.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Utils\CppWinrtLessExceptions.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Utils\WinRTConversions.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)V8JSIRuntimeHolder.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)WebSocketJSExecutorFactory.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)WinRTHttpResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)WinRTWebSocketResource.h" />
   </ItemGroup>
   <ItemGroup>

package/Shared/Shared.vcxitems.filters

@@ -133,6 +133,15 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)HermesShim.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\HttpModule.cpp">
+      <Filter>Source Files\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)WinRTHttpResource.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)Utils\WinRTConversions.cpp">
+      <Filter>Source Files\Utils</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Source Files">
@@ -183,6 +192,9 @@
     <Filter Include="Source Files\JSI">
       <UniqueIdentifier>{1a3ad55f-1297-41b3-ba2a-0f819e69270c}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Source Files\Utils">
+      <UniqueIdentifier>{e78de2f1-a7e5-4a81-b69b-4a1f7fa91cde}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(MSBuildThisFileDirectory)AsyncStorage\StorageFileIO.h">
@@ -381,6 +393,15 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)HermesShim.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="$(MSBuildThisFileDirectory)Modules\HttpModule.h">
+      <Filter>Header Files\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="$(MSBuildThisFileDirectory)WinRTHttpResource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="$(MSBuildThisFileDirectory)Utils\WinRTConversions.h">
+      <Filter>Header Files\Utils</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="$(MSBuildThisFileDirectory)tracing\rnw.wprp">

package/Shared/Utils/WinRTConversions.cpp

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "WinRTConversions.h"
+
+// Standard Library
+#include <sstream>
+
+namespace Microsoft::React::Utilities {
+
+std::string HResultToString(winrt::hresult_error const &e) {
+  std::stringstream stream;
+  stream << "[0x" << std::hex << e.code() << "] " << winrt::to_string(e.message());
+
+  return stream.str();
+}
+
+std::string HResultToString(winrt::hresult &&result) {
+  return HResultToString(winrt::hresult_error(std::move(result), winrt::hresult_error::from_abi));
+}
+
+} // namespace Microsoft::React::Utilities

package/Shared/Utils/WinRTConversions.h

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// Windows API
+#include <winrt/base.h>
+
+namespace Microsoft::React::Utilities {
+
+std::string HResultToString(winrt::hresult_error const &e);
+
+std::string HResultToString(winrt::hresult &&result);
+
+} // namespace Microsoft::React::Utilities

package/Shared/WinRTHttpResource.cpp

@@ -0,0 +1,317 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "WinRTHttpResource.h"
+
+#include <Utils/CppWinrtLessExceptions.h>
+#include <Utils/WinRTConversions.h>
+#include <utilities.h>
+
+// Windows API
+#include <winrt/Windows.Security.Cryptography.h>
+#include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.Web.Http.Headers.h>
+
+using std::function;
+using std::scoped_lock;
+using std::shared_ptr;
+using std::string;
+
+using winrt::fire_and_forget;
+using winrt::hresult_error;
+using winrt::to_hstring;
+using winrt::to_string;
+using winrt::Windows::Foundation::Uri;
+using winrt::Windows::Security::Cryptography::CryptographicBuffer;
+using winrt::Windows::Storage::StorageFile;
+using winrt::Windows::Storage::Streams::DataReader;
+using winrt::Windows::Storage::Streams::UnicodeEncoding;
+using winrt::Windows::Web::Http::HttpBufferContent;
+using winrt::Windows::Web::Http::HttpMethod;
+using winrt::Windows::Web::Http::HttpRequestMessage;
+using winrt::Windows::Web::Http::HttpStreamContent;
+using winrt::Windows::Web::Http::HttpStringContent;
+using winrt::Windows::Web::Http::IHttpClient;
+using winrt::Windows::Web::Http::IHttpContent;
+using winrt::Windows::Web::Http::Headers::HttpMediaTypeHeaderValue;
+
+namespace Microsoft::React {
+
+#pragma region WinRTHttpResource
+
+// TODO: Check for multi-thread issues if there are multiple instances.
+/*static*/ int64_t WinRTHttpResource::s_lastRequestId = 0;
+
+WinRTHttpResource::WinRTHttpResource(IHttpClient &&client) noexcept : m_client{std::move(client)} {}
+
+WinRTHttpResource::WinRTHttpResource() noexcept : WinRTHttpResource(winrt::Windows::Web::Http::HttpClient()) {}
+
+#pragma region IHttpResource
+
+void WinRTHttpResource::SendRequest(
+    string &&method,
+    string &&url,
+    Headers &&headers,
+    BodyData &&bodyData,
+    string &&responseType,
+    bool useIncrementalUpdates,
+    int64_t timeout,
+    bool withCredentials,
+    std::function<void(int64_t)> &&callback) noexcept /*override*/ {
+  auto requestId = ++s_lastRequestId;
+
+  // Enforce supported args
+  assert(responseType == "text" || responseType == "base64");
+
+  if (callback) {
+    callback(requestId);
+  }
+
+  try {
+    HttpMethod httpMethod{to_hstring(std::move(method))};
+    Uri uri{to_hstring(std::move(url))};
+    HttpRequestMessage request{httpMethod, uri};
+    HttpMediaTypeHeaderValue contentType{nullptr};
+    string contentEncoding;
+    string contentLength;
+
+    // Headers are generally case-insensitive
+    // https://www.ietf.org/rfc/rfc2616.txt section 4.2
+    for (auto &header : headers) {
+      if (_stricmp(header.first.c_str(), "content-type") == 0) {
+        bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), contentType);
+        if (!success && m_onError) {
+          return m_onError(requestId, "Failed to parse Content-Type");
+        }
+      } else if (_stricmp(header.first.c_str(), "content-encoding") == 0) {
+        contentEncoding = header.second;
+      } else if (_stricmp(header.first.c_str(), "content-length") == 0) {
+        contentLength = header.second;
+      } else if (_stricmp(header.first.c_str(), "authorization") == 0) {
+        bool success =
+            request.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
+        if (!success && m_onError) {
+          return m_onError(requestId, "Failed to append Authorization");
+        }
+      } else {
+        request.Headers().Append(to_hstring(header.first), to_hstring(header.second));
+      }
+    }
+
+    IHttpContent content{nullptr};
+    if (BodyData::Type::String == bodyData.Type) {
+      content = HttpStringContent{to_hstring(bodyData.Data)};
+    } else if (BodyData::Type::Base64 == bodyData.Type) {
+      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(bodyData.Data));
+      content = HttpBufferContent{buffer};
+    } else if (BodyData::Type::Uri == bodyData.Type) {
+      auto file = StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(bodyData.Data)}).get();
+      auto stream = file.OpenReadAsync().get();
+      content = HttpStreamContent{stream};
+    } else if (BodyData::Type::Form == bodyData.Type) {
+      // TODO: Add support
+    } else {
+      // BodyData::Type::Empty
+      // TODO: Error 'cause unsupported??
+    }
+
+    if (content != nullptr) {
+      // Attach content headers
+      if (contentType) {
+        content.Headers().ContentType(contentType);
+      }
+      if (!contentEncoding.empty()) {
+        if (!content.Headers().ContentEncoding().TryParseAdd(to_hstring(contentEncoding))) {
+          if (m_onError) {
+            m_onError(requestId, "Failed to parse Content-Encoding");
+          }
+          return;
+        }
+      }
+      if (!contentLength.empty()) {
+        const auto contentLengthHeader = _atoi64(contentLength.c_str()); // TODO: Alternatives to _atoi64?
+        content.Headers().ContentLength(contentLengthHeader);
+      }
+
+      request.Content(content);
+    }
+
+    PerformSendRequest(requestId, std::move(request), responseType == "text");
+  } catch (std::exception const &e) {
+    if (m_onError) {
+      m_onError(requestId, e.what());
+    }
+  } catch (hresult_error const &e) {
+    if (m_onError) {
+      m_onError(requestId, Utilities::HResultToString(e));
+    }
+  } catch (...) {
+    m_onError(requestId, "Unidentified error sending HTTP request");
+  }
+}
+
+void WinRTHttpResource::AbortRequest(int64_t requestId) noexcept /*override*/ {
+  ResponseType request{nullptr};
+
+  {
+    scoped_lock lock{m_mutex};
+    auto iter = m_responses.find(requestId);
+    if (iter == std::end(m_responses)) {
+      return;
+    }
+    request = iter->second;
+  }
+
+  try {
+    request.Cancel();
+  } catch (hresult_error const &e) {
+    m_onError(requestId, Utilities::HResultToString(e));
+  }
+}
+
+void WinRTHttpResource::ClearCookies() noexcept /*override*/ {
+  assert(false);
+  // NOT IMPLEMENTED
+}
+
+void WinRTHttpResource::SetOnRequest(function<void(int64_t requestId)> &&handler) noexcept /*override*/ {
+  m_onRequest = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnResponse(function<void(int64_t requestId, Response &&response)> &&handler) noexcept
+/*override*/ {
+  m_onResponse = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnData(function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept
+/*override*/ {
+  m_onData = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnError(function<void(int64_t requestId, string &&errorMessage)> &&handler) noexcept
+/*override*/ {
+  m_onError = std::move(handler);
+}
+
+#pragma endregion IHttpResource
+
+void WinRTHttpResource::TrackResponse(int64_t requestId, ResponseType response) noexcept {
+  scoped_lock lock{m_mutex};
+  m_responses[requestId] = response;
+}
+
+void WinRTHttpResource::UntrackResponse(int64_t requestId) noexcept {
+  scoped_lock lock{m_mutex};
+  m_responses.erase(requestId);
+}
+
+fire_and_forget
+WinRTHttpResource::PerformSendRequest(int64_t requestId, HttpRequestMessage &&request, bool textResponse) noexcept {
+  // Keep references after coroutine suspension.
+  auto self = shared_from_this();
+  auto coRequest = std::move(request);
+
+  // Ensure background thread
+  co_await winrt::resume_background();
+
+  try {
+    auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
+
+    self->TrackResponse(requestId, sendRequestOp);
+
+    co_await lessthrow_await_adapter<ResponseType>{sendRequestOp};
+    auto result = sendRequestOp.ErrorCode();
+    if (result < 0) {
+      if (self->m_onError) {
+        self->m_onError(requestId, Utilities::HResultToString(std::move(result)));
+      }
+      self->UntrackResponse(requestId);
+      co_return;
+    }
+
+    auto response = sendRequestOp.GetResults();
+    if (response) {
+      if (self->m_onResponse) {
+        Headers headers;
+
+        // Gather headers for both the response content and the response itself
+        // See Invoke-WebRequest PowerShell cmdlet or Chromium response handling
+        for (auto header : response.Headers()) {
+          headers.emplace(to_string(header.Key()), to_string(header.Value()));
+        }
+        for (auto header : response.Content().Headers()) {
+          headers.emplace(to_string(header.Key()), to_string(header.Value()));
+        }
+        string url = to_string(response.RequestMessage().RequestUri().AbsoluteUri());
+        self->m_onResponse(
+            requestId, {static_cast<int32_t>(response.StatusCode()), std::move(headers), std::move(url)});
+      }
+    }
+
+    // TODO: Incremental updates?
+    if (response && response.Content()) {
+      auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
+      auto reader = DataReader{inputStream};
+
+      if (textResponse) {
+        reader.UnicodeEncoding(UnicodeEncoding::Utf8);
+      }
+
+      // Only support response sizes up to 10MB.
+      // TODO: WHY????
+      co_await reader.LoadAsync(10 * 1024 * 1024);
+      auto length = reader.UnconsumedBufferLength();
+
+      if (textResponse) {
+        std::vector<uint8_t> data(length);
+        reader.ReadBytes(data);
+        string responseData = string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+
+        if (self->m_onData) {
+          self->m_onData(requestId, std::move(responseData));
+        }
+      } else {
+        auto buffer = reader.ReadBuffer(length);
+        auto data = CryptographicBuffer::EncodeToBase64String(buffer);
+        auto responseData = to_string(std::wstring_view(data));
+
+        if (self->m_onData) {
+          self->m_onData(requestId, std::move(responseData));
+        }
+      }
+    } else {
+      if (self->m_onError) {
+        self->m_onError(requestId, response == nullptr ? "request failed" : "No response content");
+      }
+    }
+  } catch (std::exception const &e) {
+    if (self->m_onError) {
+      self->m_onError(requestId, e.what());
+    }
+  } catch (hresult_error const &e) {
+    if (self->m_onError) {
+      self->m_onError(requestId, Utilities::HResultToString(e));
+    }
+  } catch (...) {
+    if (self->m_onError) {
+      self->m_onError(requestId, "Unhandled exception during request");
+    }
+  }
+
+  self->UntrackResponse(requestId);
+
+  // TODO: keep? See https://devblogs.microsoft.com/oldnewthing/?p=106160
+  co_return;
+}
+
+#pragma endregion WinRTHttpResource
+
+#pragma region IHttpResource
+
+/*static*/ shared_ptr<IHttpResource> IHttpResource::Make() noexcept {
+  return std::make_shared<WinRTHttpResource>();
+}
+
+#pragma endregion IHttpResource
+
+} // namespace Microsoft::React

package/Shared/WinRTHttpResource.h

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <IHttpResource.h>
+
+// Windows API
+#include <winrt/Windows.Web.Http.h>
+
+// Standard Library
+#include <mutex>
+
+namespace Microsoft::React {
+
+class WinRTHttpResource : public IHttpResource, public std::enable_shared_from_this<WinRTHttpResource> {
+  typedef winrt::Windows::Foundation::IAsyncOperationWithProgress<
+      winrt::Windows::Web::Http::HttpResponseMessage,
+      winrt::Windows::Web::Http::HttpProgress>
+      ResponseType;
+
+  static int64_t s_lastRequestId;
+
+  winrt::Windows::Web::Http::IHttpClient m_client;
+  std::mutex m_mutex;
+  std::unordered_map<int64_t, ResponseType> m_responses;
+
+  std::function<void(int64_t requestId)> m_onRequest;
+  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, std::string &&errorMessage /*, bool isTimeout*/)> m_onError;
+
+  void TrackResponse(int64_t requestId, ResponseType response) noexcept;
+
+  void UntrackResponse(int64_t requestId) noexcept;
+
+  winrt::fire_and_forget PerformSendRequest(
+      int64_t requestId,
+      winrt::Windows::Web::Http::HttpRequestMessage &&request,
+      bool textResponse) noexcept;
+
+ public:
+  WinRTHttpResource() noexcept;
+
+  WinRTHttpResource(winrt::Windows::Web::Http::IHttpClient &&client) noexcept;
+
+#pragma region IHttpResource
+
+  void SendRequest(
+      std::string &&method,
+      std::string &&url,
+      Headers &&headers,
+      BodyData &&bodyData,
+      std::string &&responseType,
+      bool useIncrementalUpdates,
+      int64_t timeout,
+      bool withCredentials,
+      std::function<void(int64_t)> &&callback) noexcept override;
+  void AbortRequest(int64_t requestId) noexcept override;
+  void ClearCookies() noexcept override;
+
+#pragma endregion IHttpResource
+
+  void SetOnRequest(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 SetOnError(std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)>
+                      &&handler) noexcept override;
+};
+
+} // namespace Microsoft::React

package/Shared/WinRTWebSocketResource.cpp

@@ -5,6 +5,10 @@
 
 #include <Utilities.h>
 #include <Utils/CppWinrtLessExceptions.h>
+#include <Utils/WinRTConversions.h>
+
+// MSO
+#include <dispatchQueue/dispatchQueue.h>
 
 // Windows API
 #include <winrt/Windows.Foundation.Collections.h>
@@ -44,6 +48,7 @@ using winrt::Windows::Storage::Streams::IDataWriter;
 using winrt::Windows::Storage::Streams::UnicodeEncoding;
 
 namespace {
+
 ///
 /// Implements an awaiter for Mso::DispatchQueue
 ///
@@ -72,17 +77,6 @@ auto resume_in_queue(const Mso::DispatchQueue &queue) noexcept {
   return awaitable{queue};
 } // resume_in_queue
 
-string HResultToString(hresult_error const &e) {
-  std::stringstream stream;
-  stream << "[0x" << std::hex << e.code() << "] " << winrt::to_string(e.message());
-
-  return stream.str();
-}
-
-string HResultToString(hresult &&result) {
-  return HResultToString(hresult_error(std::move(result), hresult_error::from_abi));
-}
-
 } // namespace
 
 namespace Microsoft::React {
@@ -134,12 +128,12 @@ IAsyncAction WinRTWebSocketResource::PerformConnect(Uri &&uri) noexcept {
       }
     } else {
       if (self->m_errorHandler) {
-        self->m_errorHandler({HResultToString(std::move(result)), ErrorType::Connection});
+        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Connection});
       }
     }
   } catch (hresult_error const &e) {
     if (self->m_errorHandler) {
-      self->m_errorHandler({HResultToString(e), ErrorType::Connection});
+      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Connection});
     }
   }
 
@@ -180,12 +174,12 @@ fire_and_forget WinRTWebSocketResource::PerformPing() noexcept {
       }
     } else {
       if (self->m_errorHandler) {
-        self->m_errorHandler({HResultToString(std::move(result)), ErrorType::Ping});
+        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Ping});
       }
     }
   } catch (hresult_error const &e) {
     if (self->m_errorHandler) {
-      self->m_errorHandler({HResultToString(e), ErrorType::Ping});
+      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Ping});
     }
   }
 }
@@ -246,7 +240,7 @@ fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBi
       }
     } else {
       if (self->m_errorHandler) {
-        self->m_errorHandler({HResultToString(std::move(result)), ErrorType::Send});
+        self->m_errorHandler({Utilities::HResultToString(std::move(result)), ErrorType::Send});
       }
     }
   } catch (std::exception const &e) {
@@ -256,7 +250,7 @@ fire_and_forget WinRTWebSocketResource::PerformWrite(string &&message, bool isBi
   } catch (hresult_error const &e) {
     // TODO: Remove after fixing unit tests exceptions.
     if (self->m_errorHandler) {
-      self->m_errorHandler({HResultToString(e), ErrorType::Ping});
+      self->m_errorHandler({Utilities::HResultToString(e), ErrorType::Ping});
     }
   }
 }
@@ -278,7 +272,7 @@ fire_and_forget WinRTWebSocketResource::PerformClose() noexcept {
     }
   } catch (hresult_error const &e) {
     if (m_errorHandler) {
-      m_errorHandler({HResultToString(e), ErrorType::Close});
+      m_errorHandler({Utilities::HResultToString(e), ErrorType::Close});
     }
   }
 
@@ -322,7 +316,22 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
           }
         } catch (hresult_error const &e) {
           if (self->m_errorHandler) {
-            self->m_errorHandler({HResultToString(e), ErrorType::Receive});
+            string errorMessage;
+            ErrorType errorType;
+            // See
+            // https://docs.microsoft.com/uwp/api/windows.networking.sockets.messagewebsocketmessagereceivedeventargs.getdatareader?view=winrt-19041#remarks
+            if (e.code() == WININET_E_CONNECTION_ABORTED) {
+              errorMessage = "[0x80072EFE] Underlying TCP connection suddenly terminated";
+              errorType = ErrorType::Connection;
+              self->m_errorHandler({errorMessage, errorType});
+
+              // Note: We are not clear whether all read-related errors should close the socket.
+              self->Close(CloseCode::BadPayload, std::move(errorMessage));
+            } else {
+              errorMessage = Utilities::HResultToString(e);
+              errorType = ErrorType::Receive;
+              self->m_errorHandler({errorMessage, errorType});
+            }
           }
         }
       });
@@ -346,7 +355,7 @@ void WinRTWebSocketResource::Connect(string &&url, const Protocols &protocols, c
     uri = Uri{winrt::to_hstring(url)};
   } catch (hresult_error const &e) {
     if (m_errorHandler) {
-      m_errorHandler({HResultToString(e), ErrorType::Connection});
+      m_errorHandler({Utilities::HResultToString(e), ErrorType::Connection});
     }
 
     // Abort - Mark connection as concluded.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.67.8",
+  "version": "0.67.9",
   "license": "MIT",
   "repository": {
     "type": "git",