react-native-windows 0.69.14 → 0.69.15

package/Microsoft.ReactNative/Base/CoreNativeModules.cpp

@@ -19,12 +19,8 @@
 
 namespace Microsoft::ReactNative {
 
-using winrt::Microsoft::ReactNative::ReactPropertyBag;
-
 namespace {
 
-using winrt::Microsoft::ReactNative::ReactPropertyId;
-
 bool HasPackageIdentity() noexcept {
   static const bool hasPackageIdentity = []() noexcept {
     auto packageStatics = winrt::get_activation_factory<winrt::Windows::ApplicationModel::IPackageStatics>(
@@ -39,13 +35,6 @@ bool HasPackageIdentity() noexcept {
   return hasPackageIdentity;
 }
 
-ReactPropertyId<bool> HttpUseMonolithicModuleProperty() noexcept {
-  static ReactPropertyId<bool> propId{
-      L"ReactNative.Http"
-      L"UseMonolithicModule"};
-  return propId;
-}
-
 } // namespace
 
 std::vector<facebook::react::NativeModuleDescription> GetCoreModules(
@@ -61,17 +50,15 @@ std::vector<facebook::react::NativeModuleDescription> GetCoreModules(
       [props = context->Properties()]() { return Microsoft::React::CreateHttpModule(props); },
       jsMessageQueue);
 
-  if (!ReactPropertyBag(context->Properties()).Get(HttpUseMonolithicModuleProperty())) {
-    modules.emplace_back(
-        Microsoft::React::GetBlobModuleName(),
-        [props = context->Properties()]() { return Microsoft::React::CreateBlobModule(props); },
-        batchingUIMessageQueue);
-
-    modules.emplace_back(
-        Microsoft::React::GetFileReaderModuleName(),
-        [props = context->Properties()]() { return Microsoft::React::CreateFileReaderModule(props); },
-        batchingUIMessageQueue);
-  }
+  modules.emplace_back(
+      Microsoft::React::GetBlobModuleName(),
+      [props = context->Properties()]() { return Microsoft::React::CreateBlobModule(props); },
+      batchingUIMessageQueue);
+
+  modules.emplace_back(
+      Microsoft::React::GetFileReaderModuleName(),
+      [props = context->Properties()]() { return Microsoft::React::CreateFileReaderModule(props); },
+      batchingUIMessageQueue);
 
   modules.emplace_back(
       "Timing",

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,10 +10,10 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.69.14</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.69.15</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>69</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>14</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>15</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
   </PropertyGroup>
 </Project>

package/Shared/Modules/FileReaderModule.cpp

@@ -4,6 +4,7 @@
 #include "FileReaderModule.h"
 
 #include <ReactPropertyBag.h>
+#include <sstream>
 
 // Boost Library
 #include <boost/archive/iterators/base64_from_binary.hpp>

package/Shared/Modules/HttpModule.cpp

@@ -33,8 +33,10 @@ constexpr char moduleName[] = "Networking";
 // React event names
 constexpr char completedResponse[] = "didCompleteNetworkResponse";
 constexpr char receivedResponse[] = "didReceiveNetworkResponse";
-constexpr char receivedData[] = "didReceiveNetworkData";
+constexpr char sentData[] = "didSendNetworkData";
+constexpr char receivedIncrementalData[] = "didReceiveNetworkIncrementalData";
 constexpr char receivedDataProgress[] = "didReceiveNetworkDataProgress";
+constexpr char receivedData[] = "didReceiveNetworkData";
 
 static void SetUpHttpResource(
     shared_ptr<IHttpResource> resource,
@@ -60,9 +62,6 @@ static void SetUpHttpResource(
 
   resource->SetOnData([weakReactInstance](int64_t requestId, string &&responseData) {
     SendEvent(weakReactInstance, receivedData, dynamic::array(requestId, std::move(responseData)));
-
-    // TODO: Move into separate method IF not executed right after onData()
-    SendEvent(weakReactInstance, completedResponse, dynamic::array(requestId));
   });
 
   // Explicitly declaring function type to avoid type inference ambiguity.
@@ -72,6 +71,22 @@ static void SetUpHttpResource(
   };
   resource->SetOnData(std::move(onDataDynamic));
 
+  resource->SetOnIncrementalData(
+      [weakReactInstance](int64_t requestId, string &&responseData, int64_t progress, int64_t total) {
+        SendEvent(
+            weakReactInstance,
+            receivedIncrementalData,
+            dynamic::array(requestId, std::move(responseData), progress, total));
+      });
+
+  resource->SetOnDataProgress([weakReactInstance](int64_t requestId, int64_t progress, int64_t total) {
+    SendEvent(weakReactInstance, receivedDataProgress, dynamic::array(requestId, progress, total));
+  });
+
+  resource->SetOnResponseComplete([weakReactInstance](int64_t requestId) {
+    SendEvent(weakReactInstance, completedResponse, dynamic::array(requestId));
+  });
+
   resource->SetOnError([weakReactInstance](int64_t requestId, string &&message, bool isTimeout) {
     dynamic args = dynamic::array(requestId, std::move(message));
     if (isTimeout) {
@@ -108,90 +123,90 @@ std::map<string, dynamic> HttpModule::getConstants() {
 }
 
 // clang-format off
-std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods() {
+  std::vector<facebook::xplat::module::CxxModule::Method> HttpModule::getMethods() {
 
-  return
-  {
+    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 (!holder->Module->m_isResourceSetup)
+        "sendRequest",
+        [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args, Callback cxxCallback)
         {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
+          auto holder = weakHolder.lock();
+          if (!holder) {
+            return;
+          }
 
-        auto params = facebook::xplat::jsArgAsObject(args, 0);
-        IHttpResource::Headers headers;
-        for (auto& header : params["headers"].items()) {
-          headers.emplace(header.first.getString(), header.second.getString());
-        }
+          auto resource = holder->Module->m_resource;
+          if (!holder->Module->m_isResourceSetup)
+          {
+            SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+            holder->Module->m_isResourceSetup = true;
+          }
 
-        resource->SendRequest(
-          params["method"].asString(),
-          params["url"].asString(),
-          params["requestId"].asInt(),
-          std::move(headers),
-          std::move(params["data"]),
-          params["responseType"].asString(),
-          params["incrementalUpdates"].asBool(),
-          static_cast<int64_t>(params["timeout"].asDouble()),
-          params["withCredentials"].asBool(),
-          [cxxCallback = std::move(cxxCallback)](int64_t requestId) {
-            cxxCallback({requestId});
+          auto params = facebook::xplat::jsArgAsObject(args, 0);
+          IHttpResource::Headers headers;
+          for (auto& header : params["headers"].items()) {
+            headers.emplace(header.first.getString(), header.second.getString());
           }
-        );
-      }
-    },
-    {
-      "abortRequest",
-      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+
+          resource->SendRequest(
+            params["method"].asString(),
+            params["url"].asString(),
+            params["requestId"].asInt(),
+            std::move(headers),
+            std::move(params["data"]),
+            params["responseType"].asString(),
+            params["incrementalUpdates"].asBool(),
+            static_cast<int64_t>(params["timeout"].asDouble()),
+            params["withCredentials"].asBool(),
+            [cxxCallback = std::move(cxxCallback)](int64_t requestId) {
+              cxxCallback({requestId});
+            }
+          );
+        }
+      },
       {
-        auto holder = weakHolder.lock();
-        if (!holder)
+        "abortRequest",
+        [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
         {
-          return;
-        }
+          auto holder = weakHolder.lock();
+          if (!holder)
+          {
+            return;
+          }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
+          auto resource = holder->Module->m_resource;
+          if (!holder->Module->m_isResourceSetup)
+          {
+            SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+            holder->Module->m_isResourceSetup = true;
+          }
 
-        resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
-      }
-    },
-    {
-      "clearCookies",
-      [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
+          resource->AbortRequest(facebook::xplat::jsArgAsInt(args, 0));
+        }
+      },
       {
-        auto holder = weakHolder.lock();
-        if (!holder)
+        "clearCookies",
+        [weakHolder = weak_ptr<ModuleHolder>(m_holder)](dynamic args)
         {
-          return;
-        }
+          auto holder = weakHolder.lock();
+          if (!holder)
+          {
+            return;
+          }
 
-        auto resource = holder->Module->m_resource;
-        if (!holder->Module->m_isResourceSetup)
-        {
-          SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
-          holder->Module->m_isResourceSetup = true;
-        }
+          auto resource = holder->Module->m_resource;
+          if (!holder->Module->m_isResourceSetup)
+          {
+            SetUpHttpResource(resource, holder->Module->getInstance(), holder->Module->m_inspectableProperties);
+            holder->Module->m_isResourceSetup = true;
+          }
 
-        resource->ClearCookies();
+          resource->ClearCookies();
+        }
       }
-    }
-  };
-}
+    };
+  }
 // clang-format on
 
 #pragma endregion CxxModule

package/Shared/Networking/IHttpResource.h

@@ -91,10 +91,136 @@ struct IHttpResource {
 
   virtual void ClearCookies() noexcept = 0;
 
+  /// <summary>
+  /// Sets a function to be invoked when a request has been successfully responded.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  /// </param>
   virtual void SetOnRequestSuccess(std::function<void(int64_t requestId)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when a response arrives and its headers are received.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="response">
+  ///   Object containing basic response data
+  ///   </param>
+  /// </param>
   virtual void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when response content data has been received.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="responseData">
+  ///   Response content payload (plain text or Base64-encoded)
+  ///   </param>
+  /// </param>
   virtual void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when response content data has been received.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="responseData">
+  ///   Structured response content payload (i.e. Blob data)
+  ///   </param>
+  /// </param>
   virtual void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when a response content increment has been received.
+  /// </summary>
+  /// <remarks>
+  /// The handler set by this method will only be called if the request sets the incremental updates flag.
+  /// The handler is also mutually exclusive with those set by `SetOnData`, which are used for one pass, non-incremental
+  /// updates.
+  /// </remarks>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="responseData">
+  ///   Partial response content data increment (non-accumulative)
+  ///   </param>
+  ///   <param name="progress">
+  ///   Number of bytes received so far
+  ///   </param>
+  ///   <param name="total">
+  ///   Number of total bytes to receive
+  ///   </param>
+  /// </param>
+  virtual void SetOnIncrementalData(
+      std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
+          &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when response content download progress is reported.
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  ///   <param name="progress">
+  ///   Number of bytes received so far
+  ///   </param>
+  ///   <param name="total">
+  ///   Number of total bytes to receive
+  ///   </param>
+  /// </param>
+  virtual void SetOnDataProgress(
+      std::function<void(int64_t requestId, int64_t progress, int64_t total)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when a response has been fully handled (either succeeded or failed).
+  /// </summary>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  /// </param>
+  virtual void SetOnResponseComplete(std::function<void(int64_t requestId)> &&handler) noexcept = 0;
+
+  /// <summary>
+  /// Sets a function to be invoked when an error condition is found.
+  /// </summary>
+  /// <remarks>
+  /// The handler's purpose is not to report any given HTTP error status (i.e. 403, 501).
+  /// It is meant to report application errors when executing HTTP requests.
+  /// </remarks>
+  /// <param name="handler">
+  ///
+  /// Parameters:
+  ///   <param name="requestId">
+  ///   Unique number identifying the HTTP request
+  ///   </param>
+  /// </param>
   virtual void SetOnError(
       std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> &&handler) noexcept = 0;
 };

package/Shared/Networking/OriginPolicyHttpFilter.cpp

@@ -120,12 +120,12 @@ bool OriginPolicyHttpFilter::ConstWcharComparer::operator()(const wchar_t *a, co
 }
 
 /*static*/ bool OriginPolicyHttpFilter::IsSimpleCorsRequest(HttpRequestMessage const &request) noexcept {
-  // Ensure header is in Simple CORS white list
+  // Ensure header is in Simple CORS allowlist
   for (const auto &header : request.Headers()) {
     if (s_simpleCorsRequestHeaderNames.find(header.Key().c_str()) == s_simpleCorsRequestHeaderNames.cend())
       return false;
 
-    // Ensure Content-Type value is in Simple CORS white list, if present
+    // Ensure Content-Type value is in Simple CORS allowlist, if present
     if (boost::iequals(header.Key(), L"Content-Type")) {
       if (s_simpleCorsContentTypeValues.find(header.Value().c_str()) != s_simpleCorsContentTypeValues.cend())
         return false;
@@ -135,12 +135,12 @@ bool OriginPolicyHttpFilter::ConstWcharComparer::operator()(const wchar_t *a, co
   // WinRT separates request headers from request content headers
   if (auto content = request.Content()) {
     for (const auto &header : content.Headers()) {
-      // WinRT automatically appends non-whitelisted header Content-Length when Content-Type is set. Skip it.
+      // WinRT automatically appends non-allowlisted header Content-Length when Content-Type is set. Skip it.
       if (s_simpleCorsRequestHeaderNames.find(header.Key().c_str()) == s_simpleCorsRequestHeaderNames.cend() &&
           !boost::iequals(header.Key(), "Content-Length"))
         return false;
 
-      // Ensure Content-Type value is in Simple CORS white list, if present
+      // Ensure Content-Type value is in Simple CORS allowlist, if present
       if (boost::iequals(header.Key(), L"Content-Type")) {
         if (s_simpleCorsContentTypeValues.find(header.Value().c_str()) == s_simpleCorsContentTypeValues.cend())
           return false;
@@ -148,7 +148,7 @@ bool OriginPolicyHttpFilter::ConstWcharComparer::operator()(const wchar_t *a, co
     }
   }
 
-  // Ensure method is in Simple CORS white list
+  // Ensure method is in Simple CORS allowlist
   return s_simpleCorsMethods.find(request.Method().ToString().c_str()) != s_simpleCorsMethods.cend();
 }
 
@@ -599,7 +599,7 @@ void OriginPolicyHttpFilter::ValidateResponse(HttpResponseMessage const &respons
     }
 
     if (originPolicy == OriginPolicy::SimpleCrossOriginResourceSharing) {
-      // Filter out response headers that are not in the Simple CORS whitelist
+      // Filter out response headers that are not in the Simple CORS allowlist
       std::queue<hstring> nonSimpleNames;
       for (const auto &header : response.Headers().GetView()) {
         if (s_simpleCorsResponseHeaderNames.find(header.Key().c_str()) == s_simpleCorsResponseHeaderNames.cend())
@@ -651,21 +651,26 @@ ResponseOperation OriginPolicyHttpFilter::SendPreflightAsync(HttpRequestMessage
   preflightRequest.Headers().Insert(L"Access-Control-Request-Method", coRequest.Method().ToString());
 
   auto headerNames = wstring{};
-  auto headerItr = coRequest.Headers().begin();
-  if (headerItr != coRequest.Headers().end()) {
-    headerNames += (*headerItr).Key();
+  auto writeSeparator = false;
+  for (const auto &header : coRequest.Headers()) {
+    if (writeSeparator) {
+      headerNames += L", ";
+    } else {
+      writeSeparator = true;
+    }
 
-    while (++headerItr != coRequest.Headers().end())
-      headerNames += L", " + (*headerItr).Key();
+    headerNames += header.Key();
   }
 
   if (coRequest.Content()) {
-    headerItr = coRequest.Content().Headers().begin();
-    if (headerItr != coRequest.Content().Headers().end()) {
-      headerNames += (*headerItr).Key();
+    for (const auto &header : coRequest.Content().Headers()) {
+      if (writeSeparator) {
+        headerNames += L", ";
+      } else {
+        writeSeparator = true;
+      }
 
-      while (++headerItr != coRequest.Content().Headers().end())
-        headerNames += L", " + (*headerItr).Key();
+      headerNames += header.Key();
     }
   }
 

package/Shared/Networking/WinRTHttpResource.cpp

@@ -51,8 +51,51 @@ using winrt::Windows::Web::Http::IHttpClient;
 using winrt::Windows::Web::Http::IHttpContent;
 using winrt::Windows::Web::Http::Headers::HttpMediaTypeHeaderValue;
 
+namespace {
+
+constexpr uint32_t operator""_KiB(unsigned long long int x) {
+  return static_cast<uint32_t>(1024 * x);
+}
+
+constexpr uint32_t operator""_MiB(unsigned long long int x) {
+  return static_cast<uint32_t>(1024_KiB * x);
+}
+
+constexpr char responseTypeText[] = "text";
+constexpr char responseTypeBase64[] = "base64";
+constexpr char responseTypeBlob[] = "blob";
+
+} // namespace
 namespace Microsoft::React::Networking {
 
+// May throw winrt::hresult_error
+void AttachMultipartHeaders(IHttpContent content, const dynamic &headers) {
+  HttpMediaTypeHeaderValue contentType{nullptr};
+
+  // Headers are generally case-insensitive
+  // https://www.ietf.org/rfc/rfc2616.txt section 4.2
+  // TODO: Consolidate with PerformRequest's header parsing.
+  for (auto &header : headers.items()) {
+    auto &name = header.first.getString();
+    auto &value = header.second.getString();
+
+    if (boost::iequals(name.c_str(), "Content-Type")) {
+      contentType = HttpMediaTypeHeaderValue::Parse(to_hstring(value));
+    } else if (boost::iequals(name.c_str(), "Authorization")) {
+      bool success = content.Headers().TryAppendWithoutValidation(to_hstring(name), to_hstring(value));
+      if (!success) {
+        throw hresult_error{E_INVALIDARG, L"Failed to append Authorization"};
+      }
+    } else {
+      content.Headers().Append(to_hstring(name), to_hstring(value));
+    }
+  }
+
+  if (contentType) {
+    content.Headers().ContentType(contentType);
+  }
+}
+
 #pragma region WinRTHttpResource
 
 WinRTHttpResource::WinRTHttpResource(IHttpClient &&client) noexcept : m_client{std::move(client)} {}
@@ -81,20 +124,23 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
   // Headers are generally case-insensitive
   // https://www.ietf.org/rfc/rfc2616.txt section 4.2
   for (auto &header : reqArgs->Headers) {
-    if (boost::iequals(header.first.c_str(), "Content-Type")) {
-      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), contentType);
+    auto &name = header.first;
+    auto &value = header.second;
+
+    if (boost::iequals(name.c_str(), "Content-Type")) {
+      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(value), contentType);
       if (!success) {
         if (self->m_onError) {
           self->m_onError(reqArgs->RequestId, "Failed to parse Content-Type", false);
         }
         co_return nullptr;
       }
-    } else if (boost::iequals(header.first.c_str(), "Content-Encoding")) {
-      contentEncoding = header.second;
-    } else if (boost::iequals(header.first.c_str(), "Content-Length")) {
-      contentLength = header.second;
-    } else if (boost::iequals(header.first.c_str(), "Authorization")) {
-      bool success = request.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
+    } else if (boost::iequals(name.c_str(), "Content-Encoding")) {
+      contentEncoding = value;
+    } else if (boost::iequals(name.c_str(), "Content-Length")) {
+      contentLength = value;
+    } else if (boost::iequals(name.c_str(), "Authorization")) {
+      bool success = request.Headers().TryAppendWithoutValidation(to_hstring(name), to_hstring(value));
       if (!success) {
         if (self->m_onError) {
           self->m_onError(reqArgs->RequestId, "Failed to append Authorization", false);
@@ -103,7 +149,7 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
       }
     } else {
       try {
-        request.Headers().Append(to_hstring(header.first), to_hstring(header.second));
+        request.Headers().Append(to_hstring(name), to_hstring(value));
       } catch (hresult_error const &e) {
         if (self->m_onError) {
           self->m_onError(reqArgs->RequestId, Utilities::HResultToString(e), false);
@@ -146,9 +192,31 @@ IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
       auto file = co_await StorageFile::GetFileFromApplicationUriAsync(Uri{to_hstring(data["uri"].asString())});
       auto stream = co_await file.OpenReadAsync();
       content = HttpStreamContent{std::move(stream)};
-    } else if (!data["form"].empty()) {
-      // #9535 - HTTP form data support
-      // winrt::Windows::Web::Http::HttpMultipartFormDataContent()
+    } else if (!data["formData"].empty()) {
+      winrt::Windows::Web::Http::HttpMultipartFormDataContent multiPartContent;
+      auto formData = data["formData"];
+
+      // #6046 -  Overwriting WinRT's HttpMultipartFormDataContent implicit Content-Type clears the generated boundary
+      contentType = nullptr;
+
+      for (auto &formDataPart : formData) {
+        IHttpContent formContent{nullptr};
+        if (!formDataPart["string"].isNull()) {
+          formContent = HttpStringContent{to_hstring(formDataPart["string"].asString())};
+        } else if (!formDataPart["uri"].empty()) {
+          auto filePath = to_hstring(formDataPart["uri"].asString());
+          auto file = co_await StorageFile::GetFileFromPathAsync(filePath);
+          auto stream = co_await file.OpenReadAsync();
+          formContent = HttpStreamContent{stream};
+        }
+
+        if (formContent) {
+          AttachMultipartHeaders(formContent, formDataPart["headers"]);
+          multiPartContent.Add(formContent, to_hstring(formDataPart["fieldName"].asString()));
+        }
+      } // foreach form data part
+
+      content = multiPartContent;
     }
   }
 
@@ -205,7 +273,7 @@ void WinRTHttpResource::SendRequest(
     bool withCredentials,
     std::function<void(int64_t)> &&callback) noexcept /*override*/ {
   // Enforce supported args
-  assert(responseType == "text" || responseType == "base64" || responseType == "blob");
+  assert(responseType == responseTypeText || responseType == responseTypeBase64 || responseType == responseTypeBlob);
 
   if (callback) {
     callback(requestId);
@@ -283,6 +351,22 @@ void WinRTHttpResource::SetOnData(function<void(int64_t requestId, dynamic &&res
   m_onDataDynamic = std::move(handler);
 }
 
+void WinRTHttpResource::SetOnIncrementalData(
+    function<void(int64_t requestId, string &&responseData, int64_t progress, int64_t total)> &&handler) noexcept
+/*override*/ {
+  m_onIncrementalData = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnDataProgress(
+    function<void(int64_t requestId, int64_t progress, int64_t total)> &&handler) noexcept
+/*override*/ {
+  m_onDataProgress = std::move(handler);
+}
+
+void WinRTHttpResource::SetOnResponseComplete(function<void(int64_t requestId)> &&handler) noexcept /*override*/ {
+  m_onComplete = std::move(handler);
+}
+
 void WinRTHttpResource::SetOnError(
     function<void(int64_t requestId, string &&errorMessage, bool isTimeout)> &&handler) noexcept
 /*override*/ {
@@ -316,11 +400,18 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
   auto props = winrt::multi_threaded_map<winrt::hstring, IInspectable>();
   props.Insert(L"RequestArgs", coArgs);
 
-  auto coRequest = co_await CreateRequest(std::move(coMethod), std::move(coUri), props);
-  if (!coRequest) {
-    co_return;
+  auto coRequestOp = CreateRequest(std::move(coMethod), std::move(coUri), props);
+  co_await lessthrow_await_adapter<IAsyncOperation<HttpRequestMessage>>{coRequestOp};
+  auto coRequestOpHR = coRequestOp.ErrorCode();
+  if (coRequestOpHR < 0) {
+    if (self->m_onError) {
+      self->m_onError(reqArgs->RequestId, Utilities::HResultToString(std::move(coRequestOpHR)), false);
+    }
+    co_return self->UntrackResponse(reqArgs->RequestId);
   }
 
+  auto coRequest = coRequestOp.GetResults();
+
   // If URI handler is available, it takes over request processing.
   if (auto uriHandler = self->m_uriHandler.lock()) {
     auto uri = winrt::to_string(coRequest.RequestUri().ToString());
@@ -332,6 +423,10 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
           self->m_onRequestSuccess(reqArgs->RequestId);
         }
 
+        if (self->m_onComplete) {
+          self->m_onComplete(reqArgs->RequestId);
+        }
+
         co_return;
       }
     } catch (const hresult_error &e) {
@@ -345,6 +440,9 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
 
   try {
     auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
+
+    auto isText = reqArgs->ResponseType == responseTypeText;
+
     self->TrackResponse(reqArgs->RequestId, sendRequestOp);
 
     if (reqArgs->Timeout > 0) {
@@ -411,55 +509,86 @@ WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspect
       auto inputStream = co_await response.Content().ReadAsInputStreamAsync();
       auto reader = DataReader{inputStream};
 
-      // #9510 - 10mb limit on fetch
-      co_await reader.LoadAsync(10 * 1024 * 1024);
+      // Accumulate all incoming request data in 8MB chunks
+      // Note, the minimum apparent valid chunk size is 128 KB
+      // Apple's implementation appears to grab 5-8 KB chunks
+      const uint32_t segmentSize = reqArgs->IncrementalUpdates ? 128_KiB : 8_MiB;
 
       // Let response handler take over, if set
       if (auto responseHandler = self->m_responseHandler.lock()) {
         if (responseHandler->Supports(reqArgs->ResponseType)) {
-          auto bytes = vector<uint8_t>(reader.UnconsumedBufferLength());
-          reader.ReadBytes(bytes);
-          auto blob = responseHandler->ToResponseData(std::move(bytes));
+          vector<uint8_t> responseData{};
+          while (auto loaded = co_await reader.LoadAsync(segmentSize)) {
+            auto length = reader.UnconsumedBufferLength();
+            auto data = vector<uint8_t>(length);
+            reader.ReadBytes(data);
+
+            responseData.insert(responseData.cend(), data.cbegin(), data.cend());
+          }
+
+          auto blob = responseHandler->ToResponseData(std::move(responseData));
 
           if (self->m_onDataDynamic && self->m_onRequestSuccess) {
             self->m_onDataDynamic(reqArgs->RequestId, std::move(blob));
             self->m_onRequestSuccess(reqArgs->RequestId);
           }
 
+          if (self->m_onComplete) {
+            self->m_onComplete(reqArgs->RequestId);
+          }
           co_return;
         }
       }
 
-      auto isText = reqArgs->ResponseType == "text";
       if (isText) {
         reader.UnicodeEncoding(UnicodeEncoding::Utf8);
       }
 
-      // #9510 - We currently accumulate all incoming request data in 10MB chunks.
-      uint32_t segmentSize = 10 * 1024 * 1024;
+      int64_t receivedBytes = 0;
       string responseData;
       winrt::Windows::Storage::Streams::IBuffer buffer;
-      uint32_t length;
-      do {
-        co_await reader.LoadAsync(segmentSize);
-        length = reader.UnconsumedBufferLength();
+      while (auto loaded = co_await reader.LoadAsync(segmentSize)) {
+        auto length = reader.UnconsumedBufferLength();
+        receivedBytes += length;
 
         if (isText) {
-          auto data = std::vector<uint8_t>(length);
+          auto data = vector<uint8_t>(length);
           reader.ReadBytes(data);
 
-          responseData += string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+          auto incrementData = string(Common::Utilities::CheckedReinterpretCast<char *>(data.data()), data.size());
+          // #9534 - Send incremental updates.
+          // See https://github.com/facebook/react-native/blob/v0.70.6/Libraries/Network/RCTNetworking.mm#L561
+          if (reqArgs->IncrementalUpdates) {
+            responseData = std::move(incrementData);
+
+            if (self->m_onIncrementalData) {
+              // For total, see #10849
+              self->m_onIncrementalData(reqArgs->RequestId, std::move(responseData), receivedBytes, 0 /*total*/);
+            }
+          } else {
+            responseData += std::move(incrementData);
+          }
         } else {
           buffer = reader.ReadBuffer(length);
           auto data = CryptographicBuffer::EncodeToBase64String(buffer);
 
           responseData += winrt::to_string(std::wstring_view(data));
+
+          if (self->m_onDataProgress) {
+            // For total, see #10849
+            self->m_onDataProgress(reqArgs->RequestId, receivedBytes, 0 /*total*/);
+          }
         }
-      } while (length > 0);
+      }
 
-      if (self->m_onData) {
+      // If dealing with text-incremental response data, use m_onIncrementalData instead
+      if (self->m_onData && !(reqArgs->IncrementalUpdates && isText)) {
         self->m_onData(reqArgs->RequestId, std::move(responseData));
       }
+
+      if (self->m_onComplete) {
+        self->m_onComplete(reqArgs->RequestId);
+      }
     } else {
       if (self->m_onError) {
         self->m_onError(reqArgs->RequestId, response == nullptr ? "request failed" : "No response content", false);

package/Shared/Networking/WinRTHttpResource.h

@@ -30,6 +30,10 @@ class WinRTHttpResource : public IHttpResource,
   std::function<void(int64_t requestId, std::string &&responseData)> m_onData;
   std::function<void(int64_t requestId, folly::dynamic &&responseData)> m_onDataDynamic;
   std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> m_onError;
+  std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
+      m_onIncrementalData;
+  std::function<void(int64_t requestId, int64_t progress, int64_t total)> m_onDataProgress;
+  std::function<void(int64_t requestId)> m_onComplete;
 
   // Used for IHttpModuleProxy
   std::weak_ptr<IUriHandler> m_uriHandler;
@@ -80,6 +84,12 @@ class WinRTHttpResource : public IHttpResource,
   void SetOnResponse(std::function<void(int64_t requestId, Response &&response)> &&handler) noexcept override;
   void SetOnData(std::function<void(int64_t requestId, std::string &&responseData)> &&handler) noexcept override;
   void SetOnData(std::function<void(int64_t requestId, folly::dynamic &&responseData)> &&handler) noexcept override;
+  void SetOnIncrementalData(
+      std::function<void(int64_t requestId, std::string &&responseData, int64_t progress, int64_t total)>
+          &&handler) noexcept override;
+  void SetOnDataProgress(
+      std::function<void(int64_t requestId, int64_t progress, int64_t total)> &&handler) noexcept override;
+  void SetOnResponseComplete(std::function<void(int64_t requestId)> &&handler) noexcept override;
   void SetOnError(
       std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> &&handler) noexcept override;
 

package/Shared/OInstance.cpp

@@ -27,7 +27,6 @@
 
 #include <Modules/ExceptionsManagerModule.h>
 #include <Modules/HttpModule.h>
-#include <Modules/NetworkingModule.h>
 #include <Modules/PlatformConstantsModule.h>
 #include <Modules/SourceCodeModule.h>
 #include <Modules/StatusBarManagerModule.h>
@@ -73,11 +72,7 @@ namespace Microsoft::React {
 
 /*extern*/ std::unique_ptr<facebook::xplat::module::CxxModule> CreateHttpModule(
     winrt::Windows::Foundation::IInspectable const &inspectableProperties) noexcept {
-  if (GetRuntimeOptionBool("Http.UseMonolithicModule")) {
-    return std::make_unique<NetworkingModule>();
-  } else {
-    return std::make_unique<HttpModule>(inspectableProperties);
-  }
+  return std::make_unique<HttpModule>(inspectableProperties);
 }
 
 } // namespace Microsoft::React
@@ -638,8 +633,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
   // If this code is enabled, we will have unused module instances.
   // Also, MSRN has a different property bag mechanism incompatible with this method's transitionalProps variable.
 #if (defined(_MSC_VER) && !defined(WINRT))
-  if (Microsoft::React::GetRuntimeOptionBool("Blob.EnableModule") &&
-      !Microsoft::React::GetRuntimeOptionBool("Http.UseMonolithicModule")) {
+  if (Microsoft::React::GetRuntimeOptionBool("Blob.EnableModule")) {
     modules.push_back(std::make_unique<CxxNativeModule>(
         m_innerInstance,
         Microsoft::React::GetBlobModuleName(),

package/Shared/Shared.vcxitems

@@ -50,7 +50,9 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\FileReaderModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\HttpModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\I18nModule.cpp" />
-    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.cpp">
+      <ExcludedFromBuild>true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\PlatformConstantsModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\SourceCodeModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\StatusBarManagerModule.cpp" />

package/package.json

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