react-native-windows 0.69.7 → 0.69.8

package/Shared/Networking/WinRTHttpResource.cpp

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+#undef WINRT_LEAN_AND_MEAN
+
 #include "WinRTHttpResource.h"
 
 #include <CppRuntimeOptions.h>
@@ -8,12 +10,15 @@
 #include <Utils/CppWinrtLessExceptions.h>
 #include <Utils/WinRTConversions.h>
 #include <utilities.h>
+#include "IRedirectEventSource.h"
 #include "OriginPolicyHttpFilter.h"
+#include "RedirectHttpFilter.h"
 
 // Boost Libraries
 #include <boost/algorithm/string.hpp>
 
 // Windows API
+#include <winrt/Windows.Foundation.Collections.h>
 #include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Web.Http.Headers.h>
@@ -30,7 +35,7 @@ using std::weak_ptr;
 using winrt::fire_and_forget;
 using winrt::hresult_error;
 using winrt::to_hstring;
-using winrt::to_string;
+using winrt::Windows::Foundation::IAsyncOperation;
 using winrt::Windows::Foundation::IInspectable;
 using winrt::Windows::Foundation::Uri;
 using winrt::Windows::Security::Cryptography::CryptographicBuffer;
@@ -54,6 +59,138 @@ WinRTHttpResource::WinRTHttpResource(IHttpClient &&client) noexcept : m_client{s
 
 WinRTHttpResource::WinRTHttpResource() noexcept : WinRTHttpResource(winrt::Windows::Web::Http::HttpClient{}) {}
 
+#pragma region IWinRTHttpRequestFactory
+
+IAsyncOperation<HttpRequestMessage> WinRTHttpResource::CreateRequest(
+    HttpMethod &&method,
+    Uri &&uri,
+    winrt::Windows::Foundation::Collections::IMap<winrt::hstring, IInspectable> props) noexcept /*override*/ {
+  auto request = HttpRequestMessage{std::move(method), std::move(uri)};
+  for (auto prop : props) {
+    request.Properties().Insert(prop.Key(), prop.Value());
+  }
+
+  auto iReqArgs = request.Properties().Lookup(L"RequestArgs");
+  auto reqArgs = iReqArgs.as<RequestArgs>();
+  auto self = shared_from_this();
+
+  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 : reqArgs->Headers) {
+    if (boost::iequals(header.first.c_str(), "Content-Type")) {
+      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), 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));
+      if (!success) {
+        if (self->m_onError) {
+          self->m_onError(reqArgs->RequestId, "Failed to append Authorization", false);
+        }
+        co_return nullptr;
+      }
+    } else {
+      try {
+        request.Headers().Append(to_hstring(header.first), to_hstring(header.second));
+      } catch (hresult_error const &e) {
+        if (self->m_onError) {
+          self->m_onError(reqArgs->RequestId, Utilities::HResultToString(e), false);
+        }
+        co_return nullptr;
+      }
+    }
+  }
+
+  // Initialize content
+  IHttpContent content{nullptr};
+  auto &data = reqArgs->Data;
+  if (!data.isNull()) {
+    auto bodyHandler = self->m_requestBodyHandler.lock();
+    if (bodyHandler && bodyHandler->Supports(data)) {
+      auto contentTypeString = contentType ? winrt::to_string(contentType.ToString()) : "";
+      dynamic blob;
+      try {
+        blob = bodyHandler->ToRequestBody(data, contentTypeString);
+      } catch (const std::invalid_argument &e) {
+        if (self->m_onError) {
+          self->m_onError(reqArgs->RequestId, e.what(), false);
+        }
+        co_return nullptr;
+      }
+      auto bytes = blob["bytes"];
+      auto byteVector = vector<uint8_t>(bytes.size());
+      for (auto &byte : bytes) {
+        byteVector.push_back(static_cast<uint8_t>(byte.asInt()));
+      }
+      auto view = winrt::array_view<uint8_t const>{byteVector};
+      auto buffer = CryptographicBuffer::CreateFromByteArray(view);
+      content = HttpBufferContent{std::move(buffer)};
+    } else if (!data["string"].isNull()) {
+      content = HttpStringContent{to_hstring(data["string"].asString())};
+    } else if (!data["base64"].empty()) {
+      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(data["base64"].asString()));
+      content = HttpBufferContent{std::move(buffer)};
+    } else if (!data["uri"].empty()) {
+      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()
+    }
+  }
+
+  // Attach content headers
+  if (content != nullptr) {
+    if (contentType) {
+      content.Headers().ContentType(contentType);
+    }
+    if (!contentEncoding.empty()) {
+      if (!content.Headers().ContentEncoding().TryParseAdd(to_hstring(contentEncoding))) {
+        if (self->m_onError)
+          self->m_onError(reqArgs->RequestId, "Failed to parse Content-Encoding", false);
+
+        co_return nullptr;
+      }
+    }
+
+    if (!contentLength.empty()) {
+      try {
+        const auto contentLengthHeader = std::stol(contentLength);
+        content.Headers().ContentLength(contentLengthHeader);
+      } catch (const std::invalid_argument &e) {
+        if (self->m_onError)
+          self->m_onError(reqArgs->RequestId, e.what() + string{" ["} + contentLength + "]", false);
+
+        co_return nullptr;
+      } catch (const std::out_of_range &e) {
+        if (self->m_onError)
+          self->m_onError(reqArgs->RequestId, e.what() + string{" ["} + contentLength + "]", false);
+
+        co_return nullptr;
+      }
+    }
+
+    request.Content(content);
+  }
+
+  co_return request;
+}
+
+#pragma endregion IWinRTHttpRequestFactory
+
 #pragma region IHttpResource
 
 void WinRTHttpResource::SendRequest(
@@ -77,29 +214,28 @@ void WinRTHttpResource::SendRequest(
   try {
     HttpMethod httpMethod{to_hstring(std::move(method))};
     Uri uri{to_hstring(std::move(url))};
-    HttpRequestMessage request{httpMethod, uri};
-
-    auto args = winrt::make<RequestArgs>();
-    auto concreteArgs = args.as<RequestArgs>();
-    concreteArgs->RequestId = requestId;
-    concreteArgs->Headers = std::move(headers);
-    concreteArgs->Data = std::move(data);
-    concreteArgs->IncrementalUpdates = useIncrementalUpdates;
-    concreteArgs->WithCredentials = withCredentials;
-    concreteArgs->ResponseType = std::move(responseType);
-    concreteArgs->Timeout = timeout;
-
-    PerformSendRequest(std::move(request), args);
+
+    auto iReqArgs = winrt::make<RequestArgs>();
+    auto reqArgs = iReqArgs.as<RequestArgs>();
+    reqArgs->RequestId = requestId;
+    reqArgs->Headers = std::move(headers);
+    reqArgs->Data = std::move(data);
+    reqArgs->IncrementalUpdates = useIncrementalUpdates;
+    reqArgs->WithCredentials = withCredentials;
+    reqArgs->ResponseType = std::move(responseType);
+    reqArgs->Timeout = timeout;
+
+    PerformSendRequest(std::move(httpMethod), std::move(uri), iReqArgs);
   } catch (std::exception const &e) {
     if (m_onError) {
-      m_onError(requestId, e.what());
+      m_onError(requestId, e.what(), false);
     }
   } catch (hresult_error const &e) {
     if (m_onError) {
-      m_onError(requestId, Utilities::HResultToString(e));
+      m_onError(requestId, Utilities::HResultToString(e), false);
     }
   } catch (...) {
-    m_onError(requestId, "Unidentified error sending HTTP request");
+    m_onError(requestId, "Unidentified error sending HTTP request", false);
   }
 }
 
@@ -118,7 +254,7 @@ void WinRTHttpResource::AbortRequest(int64_t requestId) noexcept /*override*/ {
   try {
     request.Cancel();
   } catch (hresult_error const &e) {
-    m_onError(requestId, Utilities::HResultToString(e));
+    m_onError(requestId, Utilities::HResultToString(e), false);
   }
 }
 
@@ -147,7 +283,8 @@ void WinRTHttpResource::SetOnData(function<void(int64_t requestId, dynamic &&res
   m_onDataDynamic = std::move(handler);
 }
 
-void WinRTHttpResource::SetOnError(function<void(int64_t requestId, string &&errorMessage)> &&handler) noexcept
+void WinRTHttpResource::SetOnError(
+    function<void(int64_t requestId, string &&errorMessage, bool isTimeout)> &&handler) noexcept
 /*override*/ {
   m_onError = std::move(handler);
 }
@@ -164,146 +301,88 @@ void WinRTHttpResource::UntrackResponse(int64_t requestId) noexcept {
   m_responses.erase(requestId);
 }
 
-fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&request, IInspectable const &args) noexcept {
+fire_and_forget
+WinRTHttpResource::PerformSendRequest(HttpMethod &&method, Uri &&rtUri, IInspectable const &args) noexcept {
   // Keep references after coroutine suspension.
   auto self = shared_from_this();
-  auto coRequest = std::move(request);
   auto coArgs = args;
-  auto coReqArgs = coArgs.as<RequestArgs>();
+  auto reqArgs = coArgs.as<RequestArgs>();
+  auto coMethod = std::move(method);
+  auto coUri = std::move(rtUri);
 
   // Ensure background thread
   co_await winrt::resume_background();
 
+  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;
+  }
+
   // 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());
     try {
-      if (uriHandler->Supports(uri, coReqArgs->ResponseType)) {
+      if (uriHandler->Supports(uri, reqArgs->ResponseType)) {
         auto blob = uriHandler->Fetch(uri);
         if (self->m_onDataDynamic && self->m_onRequestSuccess) {
-          self->m_onDataDynamic(coReqArgs->RequestId, std::move(blob));
-          self->m_onRequestSuccess(coReqArgs->RequestId);
+          self->m_onDataDynamic(reqArgs->RequestId, std::move(blob));
+          self->m_onRequestSuccess(reqArgs->RequestId);
         }
 
         co_return;
       }
     } catch (const hresult_error &e) {
       if (self->m_onError)
-        co_return self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(e));
+        co_return self->m_onError(reqArgs->RequestId, Utilities::HResultToString(e), false);
     } catch (const std::exception &e) {
       if (self->m_onError)
-        co_return self->m_onError(coReqArgs->RequestId, e.what());
+        co_return self->m_onError(reqArgs->RequestId, e.what(), false);
     }
   }
 
-  HttpMediaTypeHeaderValue contentType{nullptr};
-  string contentEncoding;
-  string contentLength;
+  try {
+    auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
+    self->TrackResponse(reqArgs->RequestId, sendRequestOp);
 
-  // Headers are generally case-insensitive
-  // https://www.ietf.org/rfc/rfc2616.txt section 4.2
-  for (auto &header : coReqArgs->Headers) {
-    if (boost::iequals(header.first.c_str(), "Content-Type")) {
-      bool success = HttpMediaTypeHeaderValue::TryParse(to_hstring(header.second), contentType);
-      if (!success && m_onError) {
-        co_return m_onError(coReqArgs->RequestId, "Failed to parse Content-Type");
-      }
-    } 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 =
-          coRequest.Headers().TryAppendWithoutValidation(to_hstring(header.first), to_hstring(header.second));
-      if (!success && m_onError) {
-        co_return m_onError(coReqArgs->RequestId, "Failed to append Authorization");
-      }
-    } else {
-      try {
-        coRequest.Headers().Append(to_hstring(header.first), to_hstring(header.second));
-      } catch (hresult_error const &e) {
-        if (self->m_onError) {
-          co_return self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(e));
-        }
-      }
-    }
-  }
+    if (reqArgs->Timeout > 0) {
+      // See https://devblogs.microsoft.com/oldnewthing/20220415-00/?p=106486
+      auto timedOut = std::make_shared<bool>(false);
+      auto sendRequestTimeout = [](auto timedOut, auto milliseconds) -> ResponseOperation {
+        // Convert milliseconds to "ticks" (10^-7 seconds)
+        co_await winrt::resume_after(winrt::Windows::Foundation::TimeSpan{milliseconds * 10000});
+        *timedOut = true;
+        co_return nullptr;
+      }(timedOut, reqArgs->Timeout);
 
-  IHttpContent content{nullptr};
-  auto &data = coReqArgs->Data;
-  if (!data.isNull()) {
-    auto bodyHandler = self->m_requestBodyHandler.lock();
-    if (bodyHandler && bodyHandler->Supports(data)) {
-      auto contentTypeString = contentType ? winrt::to_string(contentType.ToString()) : "";
-      dynamic blob;
-      try {
-        blob = bodyHandler->ToRequestBody(data, contentTypeString);
-      } catch (const std::invalid_argument &e) {
+      co_await lessthrow_await_adapter<ResponseOperation>{winrt::when_any(sendRequestOp, sendRequestTimeout)};
+
+      // Cancel either still unfinished coroutine.
+      sendRequestTimeout.Cancel();
+      sendRequestOp.Cancel();
+
+      if (*timedOut) {
         if (self->m_onError) {
-          self->m_onError(coReqArgs->RequestId, e.what());
+          // TODO: Try to replace with either:
+          //       WININET_E_TIMEOUT
+          //       ERROR_INTERNET_TIMEOUT
+          //       INET_E_CONNECTION_TIMEOUT
+          self->m_onError(reqArgs->RequestId, Utilities::HResultToString(HRESULT_FROM_WIN32(ERROR_TIMEOUT)), true);
         }
-        co_return;
+        co_return self->UntrackResponse(reqArgs->RequestId);
       }
-      auto bytes = blob["bytes"];
-      auto byteVector = vector<uint8_t>(bytes.size());
-      for (auto &byte : bytes) {
-        byteVector.push_back(static_cast<uint8_t>(byte.asInt()));
-      }
-      auto view = winrt::array_view<uint8_t>{byteVector};
-      auto buffer = CryptographicBuffer::CreateFromByteArray(view);
-      content = HttpBufferContent{std::move(buffer)};
-    } else if (!data["string"].empty()) {
-      content = HttpStringContent{to_hstring(data["string"].asString())};
-    } else if (!data["base64"].empty()) {
-      auto buffer = CryptographicBuffer::DecodeFromBase64String(to_hstring(data["base64"].asString()));
-      content = HttpBufferContent{std::move(buffer)};
-    } else if (!data["uri"].empty()) {
-      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 {
-      // Assume empty request body.
-      // content = HttpStringContent{L""};
+      co_await lessthrow_await_adapter<ResponseOperation>{sendRequestOp};
     }
-  }
 
-  if (content != nullptr) {
-    // Attach content headers
-    if (contentType) {
-      content.Headers().ContentType(contentType);
-    }
-    if (!contentEncoding.empty()) {
-      if (!content.Headers().ContentEncoding().TryParseAdd(to_hstring(contentEncoding))) {
-        if (self->m_onError)
-          self->m_onError(coReqArgs->RequestId, "Failed to parse Content-Encoding");
-
-        co_return;
-      }
-    }
-
-    if (!contentLength.empty()) {
-      const auto contentLengthHeader = _atoi64(contentLength.c_str());
-      content.Headers().ContentLength(contentLengthHeader);
-    }
-
-    coRequest.Content(content);
-  }
-
-  try {
-    coRequest.Properties().Insert(L"RequestArgs", coArgs);
-    auto sendRequestOp = self->m_client.SendRequestAsync(coRequest);
-    self->TrackResponse(coReqArgs->RequestId, sendRequestOp);
-
-    co_await lessthrow_await_adapter<ResponseOperation>{sendRequestOp};
     auto result = sendRequestOp.ErrorCode();
     if (result < 0) {
       if (self->m_onError) {
-        self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(std::move(result)));
+        self->m_onError(reqArgs->RequestId, Utilities::HResultToString(std::move(result)), false);
       }
-      co_return self->UntrackResponse(coReqArgs->RequestId);
+      co_return self->UntrackResponse(reqArgs->RequestId);
     }
 
     auto response = sendRequestOp.GetResults();
@@ -322,7 +401,7 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
         }
 
         self->m_onResponse(
-            coReqArgs->RequestId,
+            reqArgs->RequestId,
             {static_cast<int32_t>(response.StatusCode()), std::move(url), std::move(responseHeaders)});
       }
     }
@@ -337,21 +416,21 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
 
       // Let response handler take over, if set
       if (auto responseHandler = self->m_responseHandler.lock()) {
-        if (responseHandler->Supports(coReqArgs->ResponseType)) {
+        if (responseHandler->Supports(reqArgs->ResponseType)) {
           auto bytes = vector<uint8_t>(reader.UnconsumedBufferLength());
           reader.ReadBytes(bytes);
           auto blob = responseHandler->ToResponseData(std::move(bytes));
 
           if (self->m_onDataDynamic && self->m_onRequestSuccess) {
-            self->m_onDataDynamic(coReqArgs->RequestId, std::move(blob));
-            self->m_onRequestSuccess(coReqArgs->RequestId);
+            self->m_onDataDynamic(reqArgs->RequestId, std::move(blob));
+            self->m_onRequestSuccess(reqArgs->RequestId);
           }
 
           co_return;
         }
       }
 
-      auto isText = coReqArgs->ResponseType == "text";
+      auto isText = reqArgs->ResponseType == "text";
       if (isText) {
         reader.UnicodeEncoding(UnicodeEncoding::Utf8);
       }
@@ -374,33 +453,33 @@ fire_and_forget WinRTHttpResource::PerformSendRequest(HttpRequestMessage &&reque
           buffer = reader.ReadBuffer(length);
           auto data = CryptographicBuffer::EncodeToBase64String(buffer);
 
-          responseData += to_string(std::wstring_view(data));
+          responseData += winrt::to_string(std::wstring_view(data));
         }
       } while (length > 0);
 
       if (self->m_onData) {
-        self->m_onData(coReqArgs->RequestId, std::move(responseData));
+        self->m_onData(reqArgs->RequestId, std::move(responseData));
       }
     } else {
       if (self->m_onError) {
-        self->m_onError(coReqArgs->RequestId, response == nullptr ? "request failed" : "No response content");
+        self->m_onError(reqArgs->RequestId, response == nullptr ? "request failed" : "No response content", false);
       }
     }
   } catch (std::exception const &e) {
     if (self->m_onError) {
-      self->m_onError(coReqArgs->RequestId, e.what());
+      self->m_onError(reqArgs->RequestId, e.what(), false);
     }
   } catch (hresult_error const &e) {
     if (self->m_onError) {
-      self->m_onError(coReqArgs->RequestId, Utilities::HResultToString(e));
+      self->m_onError(reqArgs->RequestId, Utilities::HResultToString(e), false);
     }
   } catch (...) {
     if (self->m_onError) {
-      self->m_onError(coReqArgs->RequestId, "Unhandled exception during request");
+      self->m_onError(reqArgs->RequestId, "Unhandled exception during request", false);
     }
   }
 
-  self->UntrackResponse(coReqArgs->RequestId);
+  self->UntrackResponse(reqArgs->RequestId);
 } // PerformSendRequest
 
 #pragma region IHttpModuleProxy
@@ -431,19 +510,25 @@ void WinRTHttpResource::AddResponseHandler(shared_ptr<IResponseHandler> response
   using namespace winrt::Microsoft::ReactNative;
   using winrt::Windows::Web::Http::HttpClient;
 
-  shared_ptr<WinRTHttpResource> result;
+  auto redirFilter = winrt::make<RedirectHttpFilter>();
+  HttpClient client;
 
   if (static_cast<OriginPolicy>(GetRuntimeOptionInt("Http.OriginPolicy")) == OriginPolicy::None) {
-    result = std::make_shared<WinRTHttpResource>();
+    client = HttpClient{redirFilter};
   } else {
     auto globalOrigin = GetRuntimeOptionString("Http.GlobalOrigin");
     OriginPolicyHttpFilter::SetStaticOrigin(std::move(globalOrigin));
-    auto opFilter = winrt::make<OriginPolicyHttpFilter>();
-    auto client = HttpClient{opFilter};
+    auto opFilter = winrt::make<OriginPolicyHttpFilter>(redirFilter);
+    redirFilter.as<RedirectHttpFilter>()->SetRedirectSource(opFilter.as<IRedirectEventSource>());
 
-    result = std::make_shared<WinRTHttpResource>(std::move(client));
+    client = HttpClient{opFilter};
   }
 
+  auto result = std::make_shared<WinRTHttpResource>(std::move(client));
+
+  // Allow redirect filter to create requests based on the resource's state
+  redirFilter.as<RedirectHttpFilter>()->SetRequestFactory(weak_ptr<IWinRTHttpRequestFactory>{result});
+
   // Register resource as HTTP module proxy.
   if (inspectableProperties) {
     auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};

package/Shared/Networking/WinRTHttpResource.h

@@ -6,6 +6,7 @@
 #include "IHttpResource.h"
 
 #include <Modules/IHttpModuleProxy.h>
+#include "IWinRTHttpRequestFactory.h"
 #include "WinRTTypes.h"
 
 // Windows API
@@ -18,6 +19,7 @@ namespace Microsoft::React::Networking {
 
 class WinRTHttpResource : public IHttpResource,
                           public IHttpModuleProxy,
+                          public IWinRTHttpRequestFactory,
                           public std::enable_shared_from_this<WinRTHttpResource> {
   winrt::Windows::Web::Http::IHttpClient m_client;
   std::mutex m_mutex;
@@ -27,7 +29,7 @@ class WinRTHttpResource : public IHttpResource,
   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, 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 &&errorMessage, bool isTimeout)> m_onError;
 
   // Used for IHttpModuleProxy
   std::weak_ptr<IUriHandler> m_uriHandler;
@@ -39,7 +41,8 @@ class WinRTHttpResource : public IHttpResource,
   void UntrackResponse(int64_t requestId) noexcept;
 
   winrt::fire_and_forget PerformSendRequest(
-      winrt::Windows::Web::Http::HttpRequestMessage &&request,
+      winrt::Windows::Web::Http::HttpMethod &&method,
+      winrt::Windows::Foundation::Uri &&uri,
       winrt::Windows::Foundation::IInspectable const &args) noexcept;
 
  public:
@@ -47,6 +50,16 @@ class WinRTHttpResource : public IHttpResource,
 
   WinRTHttpResource(winrt::Windows::Web::Http::IHttpClient &&client) noexcept;
 
+#pragma region IWinRTHttpRequestFactory
+
+  winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Web::Http::HttpRequestMessage> CreateRequest(
+      winrt::Windows::Web::Http::HttpMethod &&method,
+      winrt::Windows::Foundation::Uri &&uri,
+      winrt::Windows::Foundation::Collections::IMap<winrt::hstring, winrt::Windows::Foundation::IInspectable>
+          props) noexcept override;
+
+#pragma endregion IWinRTHttpRequestFactory
+
 #pragma region IHttpResource
 
   void SendRequest(
@@ -67,8 +80,8 @@ 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 SetOnError(std::function<void(int64_t requestId, std::string &&errorMessage /*, bool isTimeout*/)>
-                      &&handler) noexcept override;
+  void SetOnError(
+      std::function<void(int64_t requestId, std::string &&errorMessage, bool isTimeout)> &&handler) noexcept override;
 
 #pragma endregion IHttpResource
 

package/Shared/OInstance.cpp

@@ -557,6 +557,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
   std::vector<std::unique_ptr<NativeModule>> modules;
   auto transitionalProps{ReactPropertyBagHelper::CreatePropertyBag()};
 
+#if (defined(_MSC_VER) && !defined(WINRT))
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
       Microsoft::React::GetHttpModuleName(),
@@ -564,6 +565,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
         return Microsoft::React::CreateHttpModule(transitionalProps);
       },
       nativeQueue));
+#endif
 
   modules.push_back(std::make_unique<CxxNativeModule>(
       m_innerInstance,
@@ -631,8 +633,13 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
       []() { return std::make_unique<StatusBarManagerModule>(); },
       nativeQueue));
 
-  // #10036 - Blob module not supported in UWP. Need to define property bag lifetime and onwership.
-  if (Microsoft::React::GetRuntimeOptionBool("Blob.EnableModule")) {
+  // These modules are instantiated separately in MSRN (Universal Windows).
+  // When there are module name colisions, the last one registered is used.
+  // 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")) {
     modules.push_back(std::make_unique<CxxNativeModule>(
         m_innerInstance,
         Microsoft::React::GetBlobModuleName(),
@@ -645,6 +652,7 @@ std::vector<std::unique_ptr<NativeModule>> InstanceImpl::GetDefaultNativeModules
         [transitionalProps]() { return Microsoft::React::CreateFileReaderModule(transitionalProps); },
         nativeQueue));
   }
+#endif
 
   return modules;
 }

package/Shared/Shared.vcxitems

@@ -56,6 +56,7 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\StatusBarManagerModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Modules\WebSocketModule.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\OriginPolicyHttpFilter.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)Networking\RedirectHttpFilter.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\WinRTHttpResource.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\WinRTWebSocketResource.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)OInstance.cpp" />
@@ -103,9 +104,12 @@
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\HttpModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Modules\NetworkingModule.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IHttpResource.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IRedirectEventSource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IWebSocketResource.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\IWinRTHttpRequestFactory.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\OriginPolicy.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\OriginPolicyHttpFilter.h" />
+    <ClInclude Include="$(MSBuildThisFileDirectory)Networking\RedirectHttpFilter.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\WinRTHttpResource.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\WinRTTypes.h" />
     <ClInclude Include="$(MSBuildThisFileDirectory)Networking\WinRTWebSocketResource.h" />