react-native-windows 0.74.7 → 0.74.9

package/Microsoft.ReactNative/Utils/ImageUtils.cpp

@@ -4,6 +4,8 @@
 #include "pch.h"
 #include "ImageUtils.h"
 
+#include <CppRuntimeOptions.h>
+#include <Networking/NetworkPropertyIds.h>
 #include <Shared/cdebug.h>
 #include <Utils/CppWinrtLessExceptions.h>
 #include <windows.Web.Http.h>
@@ -19,7 +21,9 @@ using namespace Windows::Web::Http;
 
 namespace Microsoft::ReactNative {
 
-winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(
+    winrt::Microsoft::ReactNative::IReactPropertyBag properties,
+    ReactImageSource source) {
   try {
     co_await winrt::resume_background();
 
@@ -66,6 +70,19 @@ winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageStreamAsync(ReactImag
 
     winrt::HttpRequestMessage request{httpMethod, uri};
 
+    // Ideally we'd just set m_httpClient.DefaultRequestHeaders().UserAgent().ParseAdd(m_defaultUserAgent), but when we
+    // do we start hitting E_STATE_CHANGED errors. Which appears to be this issue
+    // https://github.com/MicrosoftDocs/winrt-api/issues/2410 So instead we apply the header to each request
+    auto userAgent = Microsoft::React::GetRuntimeOptionString("Http.UserAgent");
+    if (userAgent.size() > 0) {
+      request.Headers().Append(L"User-Agent", winrt::to_hstring(userAgent));
+    } else {
+      if (auto userAgentProp = winrt::Microsoft::ReactNative::ReactPropertyBag(properties)
+                                   .Get(::Microsoft::React::DefaultUserAgentPropertyId())) {
+        request.Headers().Append(L"User-Agent", winrt::to_hstring(*userAgentProp));
+      }
+    }
+
     if (!source.headers.empty()) {
       for (auto &header : source.headers) {
         if (_stricmp(header.first.c_str(), "authorization") == 0) {
@@ -161,10 +178,12 @@ winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageInlineDataAsync(React
   co_return nullptr;
 }
 
-winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageMemoryStreamAsync(ReactImageSource source) {
+winrt::IAsyncOperation<winrt::IRandomAccessStream> GetImageMemoryStreamAsync(
+    winrt::Microsoft::ReactNative::IReactPropertyBag properties,
+    ReactImageSource source) {
   switch (source.sourceType) {
     case ImageSourceType::Download:
-      co_return co_await GetImageStreamAsync(source);
+      co_return co_await GetImageStreamAsync(properties, source);
     case ImageSourceType::InlineData:
       co_return co_await GetImageInlineDataAsync(source);
     default: // ImageSourceType::Uri

package/Microsoft.ReactNative/Utils/ImageUtils.h

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 #pragma once
+#include <ReactContext.h>
 #include <winrt/Windows.Storage.Streams.h>
 #include <string>
 
@@ -23,9 +24,10 @@ struct ReactImageSource {
 };
 
 winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>
-GetImageMemoryStreamAsync(ReactImageSource source);
+GetImageMemoryStreamAsync(winrt::Microsoft::ReactNative::IReactPropertyBag properties, ReactImageSource source);
 
 winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream> GetImageStreamAsync(
+    winrt::Microsoft::ReactNative::IReactPropertyBag properties,
     ReactImageSource source);
 
 winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::Storage::Streams::IRandomAccessStream>

package/Microsoft.ReactNative/Views/Image/ImageViewManager.cpp

@@ -114,7 +114,7 @@ const wchar_t *ImageViewManager::GetName() const {
 }
 
 XamlView ImageViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microsoft::ReactNative::JSValueObject &) {
-  return ReactImage::Create().as<winrt::Grid>();
+  return ReactImage::Create(GetReactContext()).as<winrt::Grid>();
 }
 
 ShadowNode *ImageViewManager::createShadow() const {

package/Microsoft.ReactNative/Views/Image/ReactImage.cpp

@@ -12,6 +12,7 @@
 #include <winrt/Windows.Web.Http.Headers.h>
 #include <winrt/Windows.Web.Http.h>
 
+#include <Networking/NetworkPropertyIds.h>
 #include <Views/DynamicAutomationPeer.h>
 #include "Unicode.h"
 #include "XamlView.h"
@@ -32,8 +33,10 @@ using Microsoft::Common::Unicode::Utf8ToUtf16;
 
 namespace Microsoft::ReactNative {
 
-/*static*/ winrt::com_ptr<ReactImage> ReactImage::Create() {
-  auto reactImage = winrt::make_self<ReactImage>();
+ReactImage::ReactImage(const Mso::React::IReactContext &context) : m_reactContext(&context) {}
+
+/*static*/ winrt::com_ptr<ReactImage> ReactImage::Create(const Mso::React::IReactContext &context) {
+  auto reactImage = winrt::make_self<ReactImage>(context);
   // Grid inherits the layout direction from parent and mirrors the background image in RTL mode.
   // Forcing the container to LTR mode to avoid the unexpected mirroring behavior.
   reactImage->FlowDirection(xaml::FlowDirection::LeftToRight);
@@ -162,7 +165,12 @@ void ReactImage::Source(ReactImageSource source) {
     winrt::hstring scheme{uri ? uri.SchemeName() : L""};
     winrt::hstring ext{uri ? uri.Extension() : L""};
 
-    if (((scheme == L"http") || (scheme == L"https")) && !source.headers.empty()) {
+    // Xaml default image handling can handle http/https uris.  However it will not use the specified headers in its
+    // request. If this image is using custom headers, or if we have a custom user-agent, then we have to download the
+    // image manually.
+    bool customUserAgent = !!winrt::Microsoft::ReactNative::ReactPropertyBag(m_reactContext->Properties())
+                                 .Get(Microsoft::React::DefaultUserAgentPropertyId());
+    if (((scheme == L"http") || (scheme == L"https")) && (customUserAgent || !source.headers.empty())) {
       source.sourceType = ImageSourceType::Download;
     } else if (scheme == L"data") {
       source.sourceType = ImageSourceType::InlineData;
@@ -237,7 +245,8 @@ winrt::fire_and_forget ReactImage::SetBackground(bool fireLoadEndEvent) {
 
   try {
     if (fromStream) {
-      memoryStream = co_await GetImageMemoryStreamAsync(source);
+      auto properties = m_reactContext->Properties();
+      memoryStream = co_await GetImageMemoryStreamAsync(properties, source);
 
       // Fire failed load event if we're not loading from URI and the memory stream is null.
       if (!memoryStream) {

package/Microsoft.ReactNative/Views/Image/ReactImage.h

@@ -9,6 +9,7 @@
 #include <UI.Xaml.Controls.h>
 
 #include <JSValue.h>
+#include <React.h>
 #include <Utils/ImageUtils.h>
 #include <folly/dynamic.h>
 
@@ -17,10 +18,10 @@ namespace Microsoft::ReactNative {
 struct ReactImage : xaml::Controls::GridT<ReactImage> {
   using Super = xaml::Controls::GridT<ReactImage>;
 
-  ReactImage() = default;
+  ReactImage(const Mso::React::IReactContext &context);
 
  public:
-  static winrt::com_ptr<ReactImage> Create();
+  static winrt::com_ptr<ReactImage> Create(const Mso::React::IReactContext &context);
 
   // Overrides
   winrt::Windows::Foundation::Size ArrangeOverride(winrt::Windows::Foundation::Size finalSize);
@@ -59,6 +60,7 @@ struct ReactImage : xaml::Controls::GridT<ReactImage> {
   double GetHeight();
 
   bool m_useCompositionBrush{false};
+  Mso::CntPtr<const Mso::React::IReactContext> m_reactContext;
   float m_blurRadius{0};
   int m_imageSourceId{0};
   ReactImageSource m_imageSource;

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.74.7</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.74.9</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>74</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>7</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>9</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>92b63ecf09a8f2c61a3c972e76bfdb535707d87b</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>9efa2f6851a90be02d599f18a224bf6c89032409</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Modules/FileReaderModule.cpp

@@ -5,6 +5,7 @@
 
 #include <CreateModules.h>
 #include <ReactPropertyBag.h>
+#include "Networking/NetworkPropertyIds.h"
 
 // React Native
 #include <cxxreact/JsArgumentHelpers.h>
@@ -113,9 +114,8 @@ std::vector<module::CxxModule::Method> FileReaderModule::getMethods() {
 #pragma region FileReaderTurboModule
 
 void FileReaderTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
-  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
   auto props = reactContext.Properties();
-  auto prop = props.Get(propId);
+  auto prop = props.Get(BlobModulePersistorPropertyId());
   m_resource = IFileReaderResource::Make(prop.Value());
 }
 
@@ -195,10 +195,9 @@ void FileReaderTurboModule::ReadAsText(
 
 /*extern*/ std::unique_ptr<module::CxxModule> CreateFileReaderModule(
     IInspectable const &inspectableProperties) noexcept {
-  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
   auto propBag = msrn::ReactPropertyBag{inspectableProperties.try_as<msrn::IReactPropertyBag>()};
 
-  if (auto prop = propBag.Get(propId)) {
+  if (auto prop = propBag.Get(BlobModulePersistorPropertyId())) {
     auto weakBlobPersistor = prop.Value();
 
     return std::make_unique<FileReaderModule>(weakBlobPersistor);

package/Shared/Modules/WebSocketModule.cpp

@@ -10,6 +10,7 @@
 #include <Modules/CxxModuleUtilities.h>
 #include <Modules/IWebSocketModuleContentHandler.h>
 #include <ReactPropertyBag.h>
+#include "Networking/NetworkPropertyIds.h"
 
 // fmt
 #include <fmt/format.h>
@@ -52,12 +53,16 @@ using Microsoft::React::Networking::IWebSocketResource;
 
 constexpr char s_moduleName[] = "WebSocketModule";
 constexpr wchar_t s_moduleNameW[] = L"WebSocketModule";
-constexpr wchar_t s_proxyNameW[] = L"WebSocketModule.Proxy";
-constexpr wchar_t s_sharedStateNameW[] = L"WebSocketModule.SharedState";
-constexpr wchar_t s_contentHandlerNameW[] = L"BlobModule.ContentHandler";
 
 msrn::ReactModuleProvider s_moduleProvider = msrn::MakeTurboModuleProvider<Microsoft::React::WebSocketTurboModule>();
 
+const ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>>
+WebSocketModuleSharedStatePropertyId() noexcept {
+  static const ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>> prop{
+      L"WebSocketModule.SharedState"};
+  return prop;
+}
+
 static shared_ptr<IWebSocketResource>
 GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedState> weakState) {
   auto state = weakState.lock();
@@ -121,9 +126,7 @@ GetOrCreateWebSocket(int64_t id, string &&url, weak_ptr<WebSocketModule::SharedS
 
           auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
           shared_ptr<Microsoft::React::IWebSocketModuleContentHandler> contentHandler;
-          auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<Microsoft::React::IWebSocketModuleContentHandler>>>{
-              s_contentHandlerNameW};
-          if (auto prop = propBag.Get(propId))
+          if (auto prop = propBag.Get(Microsoft::React::BlobModuleContentHandlerPropertyId()))
             contentHandler = prop.Value().lock();
 
           if (contentHandler) {
@@ -174,13 +177,11 @@ WebSocketModule::WebSocketModule(winrt::Windows::Foundation::IInspectable const
 
   auto propBag = ReactPropertyBag{m_sharedState->InspectableProps.try_as<IReactPropertyBag>()};
 
-  auto proxyPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{s_proxyNameW};
   auto proxy = weak_ptr<IWebSocketModuleProxy>{m_proxy};
-  propBag.Set(proxyPropId, std::move(proxy));
+  propBag.Set(WebSocketModuleProxyPropertyId(), std::move(proxy));
 
-  auto statePropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<SharedState>>>{s_sharedStateNameW};
   auto state = weak_ptr<SharedState>{m_sharedState};
-  propBag.Set(statePropId, std::move(state));
+  propBag.Set(WebSocketModuleSharedStatePropertyId(), std::move(state));
 }
 
 WebSocketModule::~WebSocketModule() noexcept /*override*/ {
@@ -314,8 +315,7 @@ WebSocketModuleProxy::WebSocketModuleProxy(IInspectable const &inspectableProper
 
 void WebSocketModuleProxy::SendBinary(string &&base64String, int64_t id) noexcept /*override*/ {
   auto propBag = ReactPropertyBag{m_inspectableProps.try_as<IReactPropertyBag>()};
-  auto sharedPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>>{s_sharedStateNameW};
-  auto state = propBag.Get(sharedPropId).Value();
+  auto state = propBag.Get(WebSocketModuleSharedStatePropertyId()).Value();
 
   weak_ptr weakWs = GetOrCreateWebSocket(id, {}, std::move(state));
   if (auto sharedWs = weakWs.lock()) {
@@ -355,9 +355,8 @@ shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id,
   rc->SetOnMessage([id, context = m_context](size_t length, const string &message, bool isBinary) {
     auto args = msrn::JSValueObject{{"id", id}, {"type", isBinary ? "binary" : "text"}};
     shared_ptr<IWebSocketModuleContentHandler> contentHandler;
-    auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{s_contentHandlerNameW};
     auto propBag = context.Properties();
-    if (auto prop = propBag.Get(propId))
+    if (auto prop = propBag.Get(BlobModuleContentHandlerPropertyId()))
       contentHandler = prop.Value().lock();
 
     if (contentHandler) {
@@ -399,9 +398,8 @@ void WebSocketTurboModule::Initialize(msrn::ReactContext const &reactContext) no
   m_context = reactContext.Handle();
   m_proxy = std::make_shared<WebSocketTurboModuleProxy>(m_resourceMap);
 
-  auto proxyPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{s_proxyNameW};
   auto proxy = weak_ptr<IWebSocketModuleProxy>{m_proxy};
-  m_context.Properties().Set(proxyPropId, std::move(proxy));
+  m_context.Properties().Set(WebSocketModuleProxyPropertyId(), std::move(proxy));
 }
 
 void WebSocketTurboModule::Connect(

package/Shared/Networking/DefaultBlobResource.cpp

@@ -6,6 +6,7 @@
 #include <Modules/IHttpModuleProxy.h>
 #include <Modules/IWebSocketModuleProxy.h>
 #include <utilities.h>
+#include "NetworkPropertyIds.h"
 
 // Boost Libraries
 #include <boost/uuid/uuid_io.hpp>
@@ -63,13 +64,9 @@ DefaultBlobResource::DefaultBlobResource(
   auto requestBodyHandler = std::make_shared<BlobModuleRequestBodyHandler>(blobPersistor);
   auto responseHandler = std::make_shared<BlobModuleResponseHandler>(blobPersistor);
 
-  auto contentHandlerPropId =
-      ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{L"BlobModule.ContentHandler"};
-  propBag.Set(contentHandlerPropId, weak_ptr<IWebSocketModuleContentHandler>{contentHandler});
+  propBag.Set(BlobModuleContentHandlerPropertyId(), weak_ptr<IWebSocketModuleContentHandler>{contentHandler});
 
-  auto blobPersistorPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IBlobPersistor>>>{L"Blob.Persistor"};
-  ;
-  propBag.Set(blobPersistorPropId, weak_ptr<IBlobPersistor>{blobPersistor});
+  propBag.Set(BlobModulePersistorPropertyId(), weak_ptr<IBlobPersistor>{blobPersistor});
 
   auto result = std::make_shared<DefaultBlobResource>(
       blobPersistor, contentHandler, requestBodyHandler, responseHandler, propBag);
@@ -79,10 +76,8 @@ DefaultBlobResource::DefaultBlobResource(
 
 void DefaultBlobResource::SendOverSocket(string &&blobId, int64_t offset, int64_t size, int64_t socketId) noexcept
 /*override*/ {
-  auto propId =
-      msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
   shared_ptr<IWebSocketModuleProxy> wsProxy;
-  if (auto prop = m_propertyBag.Get(propId)) {
+  if (auto prop = m_propertyBag.Get(WebSocketModuleProxyPropertyId())) {
     wsProxy = prop.Value().lock();
   }
   if (!wsProxy) {
@@ -137,10 +132,8 @@ void DefaultBlobResource::Release(string &&blobId) noexcept /*override*/ {
 }
 
 void DefaultBlobResource::AddNetworkingHandler() noexcept /*override*/ {
-  auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
-
   bool handlerAdded = false;
-  if (auto prop = m_propertyBag.Get(propId)) {
+  if (auto prop = m_propertyBag.Get(HttpModuleProxyPropertyId())) {
     if (auto httpHandler = prop.Value().lock()) {
       httpHandler->AddRequestBodyHandler(m_requestBodyHandler);
       httpHandler->AddResponseHandler(m_responseHandler);
@@ -152,8 +145,7 @@ void DefaultBlobResource::AddNetworkingHandler() noexcept /*override*/ {
   // Best-effort approach to set up the request/response handlers by exposing this interface to dependents
   // (i.e. IHttpResource).
   if (!handlerAdded) {
-    auto propId = msrn::ReactPropertyId<msrn::ReactNonAbiValue<weak_ptr<IBlobResource>>>{L"Blob.Resource"};
-    m_propertyBag.Set(propId, weak_ptr<IBlobResource>(shared_from_this()));
+    m_propertyBag.Set(BlobResourcePropertyId(), weak_ptr<IBlobResource>(shared_from_this()));
   }
 }
 

package/Shared/Networking/NetworkPropertyIds.cpp

@@ -0,0 +1,60 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "NetworkPropertyIds.h"
+
+namespace Microsoft::React {
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IWebSocketModuleContentHandler>>>
+BlobModuleContentHandlerPropertyId() noexcept {
+  static const winrt::Microsoft::ReactNative::ReactPropertyId<
+      winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IWebSocketModuleContentHandler>>>
+      prop{L"BlobModule.ContentHandler"};
+  return prop;
+}
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IBlobPersistor>>>
+BlobModulePersistorPropertyId() noexcept {
+  static const winrt::Microsoft::ReactNative::ReactPropertyId<
+      winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IBlobPersistor>>>
+      prop{L"Blob.Persistor"};
+  return prop;
+}
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IWebSocketModuleProxy>>>
+WebSocketModuleProxyPropertyId() noexcept {
+  static const winrt::Microsoft::ReactNative::ReactPropertyId<
+      winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IWebSocketModuleProxy>>>
+      prop{L"WebSocketModule.Proxy"};
+  return prop;
+}
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IHttpModuleProxy>>>
+HttpModuleProxyPropertyId() noexcept {
+  static const winrt::Microsoft::ReactNative::ReactPropertyId<
+      winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IHttpModuleProxy>>>
+      prop{L"HttpModule.Proxy"};
+  return prop;
+}
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<Networking::IBlobResource>>>
+BlobResourcePropertyId() noexcept {
+  static const winrt::Microsoft::ReactNative::ReactPropertyId<
+      winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<Networking::IBlobResource>>>
+      prop{L"Blob.Resource"};
+  return prop;
+}
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<winrt::hstring> DefaultUserAgentPropertyId() noexcept {
+  static const winrt::Microsoft::ReactNative::ReactPropertyId<winrt::hstring> prop{L"ReactNative", L"UserAgent"};
+  return prop;
+}
+
+} // namespace Microsoft::React

package/Shared/Networking/NetworkPropertyIds.h

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <ReactPropertyBag.h>
+
+namespace Microsoft::React {
+
+struct IWebSocketModuleContentHandler;
+struct IBlobPersistor;
+struct IWebSocketModuleProxy;
+struct IHttpModuleProxy;
+
+namespace Networking {
+struct IBlobResource;
+}
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IWebSocketModuleContentHandler>>>
+BlobModuleContentHandlerPropertyId() noexcept;
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IBlobPersistor>>>
+BlobModulePersistorPropertyId() noexcept;
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IWebSocketModuleProxy>>>
+WebSocketModuleProxyPropertyId() noexcept;
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<IHttpModuleProxy>>>
+HttpModuleProxyPropertyId() noexcept;
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<
+    winrt::Microsoft::ReactNative::ReactNonAbiValue<std::weak_ptr<Networking::IBlobResource>>>
+BlobResourcePropertyId() noexcept;
+
+const winrt::Microsoft::ReactNative::ReactPropertyId<winrt::hstring> DefaultUserAgentPropertyId() noexcept;
+
+} // namespace Microsoft::React

package/Shared/Networking/RedirectHttpFilter.cpp

@@ -42,10 +42,12 @@ namespace Microsoft::React::Networking {
 RedirectHttpFilter::RedirectHttpFilter(
     size_t maxRedirects,
     IHttpFilter &&innerFilter,
-    IHttpFilter &&innerFilterWithNoCredentials) noexcept
+    IHttpFilter &&innerFilterWithNoCredentials,
+    winrt::hstring defaultUserAgent) noexcept
     : m_maximumRedirects{maxRedirects},
       m_innerFilter{std::move(innerFilter)},
-      m_innerFilterWithNoCredentials{std::move(innerFilterWithNoCredentials)} {
+      m_innerFilterWithNoCredentials{std::move(innerFilterWithNoCredentials)},
+      m_defaultUserAgent(defaultUserAgent) {
   // Prevent automatic redirections.
   if (auto baseFilter = m_innerFilter.try_as<IHttpBaseProtocolFilter>()) {
     baseFilter.AllowAutoRedirect(false);
@@ -57,13 +59,21 @@ RedirectHttpFilter::RedirectHttpFilter(
   }
 }
 
-RedirectHttpFilter::RedirectHttpFilter(IHttpFilter &&innerFilter, IHttpFilter &&innerFilterWithNoCredentials) noexcept
-    : RedirectHttpFilter(DefaultMaxRedirects, std::move(innerFilter), std::move(innerFilterWithNoCredentials)) {}
+RedirectHttpFilter::RedirectHttpFilter(
+    IHttpFilter &&innerFilter,
+    IHttpFilter &&innerFilterWithNoCredentials,
+    winrt::hstring defaultUserAgent) noexcept
+    : RedirectHttpFilter(
+          DefaultMaxRedirects,
+          std::move(innerFilter),
+          std::move(innerFilterWithNoCredentials),
+          defaultUserAgent) {}
 
-RedirectHttpFilter::RedirectHttpFilter() noexcept
+RedirectHttpFilter::RedirectHttpFilter(winrt::hstring defaultUserAgent) noexcept
     : RedirectHttpFilter(
           winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter{},
-          winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter{}) {}
+          winrt::Windows::Web::Http::Filters::HttpBaseProtocolFilter{},
+          defaultUserAgent) {}
 
 void RedirectHttpFilter::SetRequestFactory(std::weak_ptr<IWinRTHttpRequestFactory> factory) noexcept {
   m_requestFactory = factory;
@@ -215,9 +225,8 @@ ResponseOperation RedirectHttpFilter::SendRequestAsync(HttpRequestMessage const
   do {
     // Set User-Agent
     // See https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
-    auto userAgent = GetRuntimeOptionString("Http.UserAgent");
-    if (userAgent.size() > 0) {
-      coRequest.Headers().Append(L"User-Agent", winrt::to_hstring(userAgent));
+    if (!m_defaultUserAgent.empty()) {
+      coRequest.Headers().Append(L"User-Agent", m_defaultUserAgent);
     }
 
     // Send subsequent requests through the filter that doesn't have the credentials included in the first request

package/Shared/Networking/RedirectHttpFilter.h

@@ -31,18 +31,21 @@ class RedirectHttpFilter : public winrt::implements<
   winrt::com_ptr<Microsoft::React::Networking::IRedirectEventSource> m_redirEventSrc;
   bool m_allowAutoRedirect{true};
   size_t m_maximumRedirects;
+  winrt::hstring m_defaultUserAgent;
 
  public:
   RedirectHttpFilter(
       size_t maxRedirects,
       winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilter,
-      winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilterWithNoCredentials) noexcept;
+      winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilterWithNoCredentials,
+      winrt::hstring defaultUserAgent) noexcept;
 
   RedirectHttpFilter(
       winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilter,
-      winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilterWithNoCredentials) noexcept;
+      winrt::Windows::Web::Http::Filters::IHttpFilter &&innerFilterWithNoCredentials,
+      winrt::hstring defaultUserAgent) noexcept;
 
-  RedirectHttpFilter() noexcept;
+  RedirectHttpFilter(winrt::hstring defaultUserAgent) noexcept;
 
   void SetRequestFactory(std::weak_ptr<IWinRTHttpRequestFactory> factory) noexcept;
 

package/Shared/Networking/WinRTHttpResource.cpp

@@ -5,6 +5,7 @@
 
 #include "WinRTHttpResource.h"
 
+#include "HttpSettings.g.cpp"
 #include <CppRuntimeOptions.h>
 #include <Networking/IBlobResource.h>
 #include <ReactPropertyBag.h>
@@ -12,6 +13,7 @@
 #include <Utils/WinRTConversions.h>
 #include <utilities.h>
 #include "IRedirectEventSource.h"
+#include "Networking/NetworkPropertyIds.h"
 #include "OriginPolicyHttpFilter.h"
 #include "RedirectHttpFilter.h"
 
@@ -310,7 +312,9 @@ void WinRTHttpResource::SendRequest(
       m_onError(requestId, Utilities::HResultToString(e), false);
     }
   } catch (...) {
-    m_onError(requestId, "Unidentified error sending HTTP request", false);
+    if (m_onError) {
+      m_onError(requestId, "Unidentified error sending HTTP request", false);
+    }
   }
 }
 
@@ -329,7 +333,9 @@ void WinRTHttpResource::AbortRequest(int64_t requestId) noexcept /*override*/ {
   try {
     request.Cancel();
   } catch (hresult_error const &e) {
-    m_onError(requestId, Utilities::HResultToString(e), false);
+    if (m_onError) {
+      m_onError(requestId, Utilities::HResultToString(e), false);
+    }
   }
 }
 
@@ -645,7 +651,20 @@ void WinRTHttpResource::AddResponseHandler(shared_ptr<IResponseHandler> response
   using namespace winrt::Microsoft::ReactNative;
   using winrt::Windows::Web::Http::HttpClient;
 
-  auto redirFilter = winrt::make<RedirectHttpFilter>();
+  winrt::hstring defaultUserAgent;
+  if (inspectableProperties) {
+    auto propBag = ReactPropertyBag{inspectableProperties.as<IReactPropertyBag>()};
+    if (auto userAgentProp = propBag.Get(DefaultUserAgentPropertyId())) {
+      defaultUserAgent = *userAgentProp;
+    }
+  }
+
+  auto userAgent = GetRuntimeOptionString("Http.UserAgent");
+  if (userAgent.size() > 0) {
+    defaultUserAgent = winrt::to_hstring(userAgent);
+  }
+
+  auto redirFilter = winrt::make<RedirectHttpFilter>(defaultUserAgent);
   HttpClient client;
 
   if (static_cast<OriginPolicy>(GetRuntimeOptionInt("Http.OriginPolicy")) == OriginPolicy::None) {
@@ -665,14 +684,12 @@ void WinRTHttpResource::AddResponseHandler(shared_ptr<IResponseHandler> response
 
   // Register resource as HTTP module proxy.
   if (inspectableProperties) {
-    auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IHttpModuleProxy>>>{L"HttpModule.Proxy"};
-    auto propBag = ReactPropertyBag{inspectableProperties.try_as<IReactPropertyBag>()};
+    auto propBag = ReactPropertyBag{inspectableProperties.as<IReactPropertyBag>()};
     auto moduleProxy = weak_ptr<IHttpModuleProxy>{result};
-    propBag.Set(propId, std::move(moduleProxy));
+    propBag.Set(HttpModuleProxyPropertyId(), std::move(moduleProxy));
 
     // #11439 - Best-effort attempt to set up the HTTP handler after an initial call to addNetworkingHandler failed.
-    auto blobRcPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<Networking::IBlobResource>>>{L"Blob.Resource"};
-    if (auto prop = propBag.Get(blobRcPropId)) {
+    if (auto prop = propBag.Get(BlobResourcePropertyId())) {
       if (auto blobRc = prop.Value().lock()) {
         blobRc->AddNetworkingHandler();
       }
@@ -690,3 +707,14 @@ void WinRTHttpResource::AddResponseHandler(shared_ptr<IResponseHandler> response
 #pragma endregion IHttpResource
 
 } // namespace Microsoft::React::Networking
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+void HttpSettings::SetDefaultUserAgent(
+    const winrt::Microsoft::ReactNative::ReactInstanceSettings &settings,
+    const winrt::hstring &userAgent) noexcept {
+  winrt::Microsoft::ReactNative::ReactPropertyBag(settings.Properties())
+      .Set(::Microsoft::React::DefaultUserAgentPropertyId(), userAgent);
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Shared/Networking/WinRTHttpResource.h

@@ -5,6 +5,7 @@
 
 #include "IHttpResource.h"
 
+#include "HttpSettings.g.h"
 #include <Modules/IHttpModuleProxy.h>
 #include "IWinRTHttpRequestFactory.h"
 #include "WinRTTypes.h"
@@ -108,3 +109,19 @@ class WinRTHttpResource : public IHttpResource,
 };
 
 } // namespace Microsoft::React::Networking
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+struct HttpSettings {
+  HttpSettings() = default;
+
+  static void SetDefaultUserAgent(
+      const winrt::Microsoft::ReactNative::ReactInstanceSettings &settings,
+      const winrt::hstring &userAgent) noexcept;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation
+
+namespace winrt::Microsoft::ReactNative::factory_implementation {
+struct HttpSettings : HttpSettingsT<HttpSettings, implementation::HttpSettings> {};
+} // namespace winrt::Microsoft::ReactNative::factory_implementation