react-native-windows 0.71.40 → 0.71.42

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -548,6 +548,9 @@ void ReactInstanceWin::Initialize() noexcept {
             auto omitNetCxxPropName = ReactPropertyBagHelper::GetName(nullptr, L"OmitNetworkingCxxModules");
             auto omitNetCxxPropValue = m_options.Properties.Get(omitNetCxxPropName);
             devSettings->omitNetworkingCxxModules = winrt::unbox_value_or(omitNetCxxPropValue, false);
+            auto useWebSocketTurboModulePropName = ReactPropertyBagHelper::GetName(nullptr, L"UseWebSocketTurboModule");
+            auto useWebSocketTurboModulePropValue = m_options.Properties.Get(useWebSocketTurboModulePropName);
+            devSettings->useWebSocketTurboModule = winrt::unbox_value_or(useWebSocketTurboModulePropValue, false);
             auto bundleRootPath = devSettings->bundleRootPath;
             auto instanceWrapper = facebook::react::CreateReactInstance(
                 std::shared_ptr<facebook::react::Instance>(strongThis->m_instance.Load()),

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.71.40</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.71.42</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>71</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>40</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>42</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>75b42021dbf4734610a01134b86399210b2b62ed</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>d755604625a3cf4b704edb607e823f0f7367ebb5</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/DevSettings.h

@@ -102,6 +102,9 @@ struct DevSettings {
 
   // Transitory. Used to indicate whether or not to load networking types in the default Cxx module registry.
   bool omitNetworkingCxxModules{false};
+
+  // OC:8368383 - Memory leak under investigation.
+  bool useWebSocketTurboModule{false};
 };
 
 } // namespace react

package/Shared/Modules/WebSocketModule.cpp

@@ -52,6 +52,9 @@ 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>();
 
@@ -119,7 +122,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>>>{
-              L"BlobModule.ContentHandler"};
+              s_contentHandlerNameW};
           if (auto prop = propBag.Get(propId))
             contentHandler = prop.Value().lock();
 
@@ -171,11 +174,11 @@ WebSocketModule::WebSocketModule(winrt::Windows::Foundation::IInspectable const
 
   auto propBag = ReactPropertyBag{m_sharedState->InspectableProps.try_as<IReactPropertyBag>()};
 
-  auto proxyPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{L"WebSocketModule.Proxy"};
+  auto proxyPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleProxy>>>{s_proxyNameW};
   auto proxy = weak_ptr<IWebSocketModuleProxy>{m_proxy};
   propBag.Set(proxyPropId, std::move(proxy));
 
-  auto statePropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<SharedState>>>{L"WebSocketModule.SharedState"};
+  auto statePropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<SharedState>>>{s_sharedStateNameW};
   auto state = weak_ptr<SharedState>{m_sharedState};
   propBag.Set(statePropId, std::move(state));
 }
@@ -309,10 +312,9 @@ vector<facebook::xplat::module::CxxModule::Method> WebSocketModule::getMethods()
 WebSocketModuleProxy::WebSocketModuleProxy(IInspectable const &inspectableProperties) noexcept
     : m_inspectableProps{inspectableProperties} {}
 
-void WebSocketModuleProxy::SendBinary(std::string &&base64String, int64_t id) noexcept /*override*/ {
+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>>>{L"WebSocketModule.SharedState"};
+  auto sharedPropId = ReactPropertyId<ReactNonAbiValue<weak_ptr<WebSocketModule::SharedState>>>{s_sharedStateNameW};
   auto state = propBag.Get(sharedPropId).Value();
 
   weak_ptr weakWs = GetOrCreateWebSocket(id, {}, std::move(state));
@@ -353,8 +355,7 @@ 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>>>{L"BlobModule.ContentHandler"};
+    auto propId = ReactPropertyId<ReactNonAbiValue<weak_ptr<IWebSocketModuleContentHandler>>>{s_contentHandlerNameW};
     auto propBag = context.Properties();
     if (auto prop = propBag.Get(propId))
       contentHandler = prop.Value().lock();
@@ -396,6 +397,11 @@ shared_ptr<IWebSocketResource> WebSocketTurboModule::CreateResource(int64_t id,
 
 void WebSocketTurboModule::Initialize(msrn::ReactContext const &reactContext) noexcept {
   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));
 }
 
 void WebSocketTurboModule::Connect(
@@ -487,6 +493,29 @@ void WebSocketTurboModule::RemoveListeners(double /*count*/) noexcept {}
 
 #pragma endregion WebSocketTurboModule
 
+#pragma region WebSocketTurboModuleProxy
+
+WebSocketTurboModuleProxy::WebSocketTurboModuleProxy(
+    std::unordered_map<double, shared_ptr<IWebSocketResource>> &resourceMap) noexcept
+    : m_resourceMap{resourceMap} {}
+
+#pragma endregion WebSocketTurboModuleProxy
+
+void WebSocketTurboModuleProxy::SendBinary(string &&base64String, int64_t id) noexcept /*override*/
+{
+  auto rcItr = m_resourceMap.find(static_cast<double>(id));
+  if (rcItr == m_resourceMap.cend()) {
+    return;
+  }
+
+  weak_ptr<IWebSocketResource> weakRc = (*rcItr).second;
+  if (auto rc = weakRc.lock()) {
+    rc->SendBinary(std::move(base64String));
+  }
+}
+
+#pragma region WebSocketTurboModule
+
 /*extern*/ const char *GetWebSocketModuleName() noexcept {
   return s_moduleName;
 }

package/Shared/Modules/WebSocketTurboModule.h

@@ -10,6 +10,20 @@
 
 namespace Microsoft::React {
 
+class WebSocketTurboModuleProxy final : public IWebSocketModuleProxy {
+  std::unordered_map<double, std::shared_ptr<Networking::IWebSocketResource>> &m_resourceMap;
+
+ public:
+  WebSocketTurboModuleProxy(
+      std::unordered_map<double, std::shared_ptr<Networking::IWebSocketResource>> &resourceMap) noexcept;
+
+#pragma region IWebSocketModuleProxy
+
+  void SendBinary(std::string &&base64String, int64_t id) noexcept override;
+
+#pragma endregion
+};
+
 REACT_MODULE(WebSocketTurboModule, L"WebSocketModule")
 struct WebSocketTurboModule {
   using ModuleSpec = ReactNativeSpecs::WebSocketModuleSpec;
@@ -47,6 +61,11 @@ struct WebSocketTurboModule {
 
   winrt::Microsoft::ReactNative::ReactContext m_context;
   std::unordered_map<double, std::shared_ptr<Networking::IWebSocketResource>> m_resourceMap;
+
+  /// <summary>
+  /// Exposes a subset of the module's methods.
+  /// </summary>
+  std::shared_ptr<IWebSocketModuleProxy> m_proxy;
 };
 
 } // namespace Microsoft::React

package/Shared/OInstance.cpp

@@ -556,14 +556,18 @@ 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))
-  // Applications using the Windows ABI feature should loade the networking TurboModule variants instead.
-  if (!m_devSettings->omitNetworkingCxxModules) {
+
+  // OC:8368383 - Memory leak under investigation.
+  if (!m_devSettings->useWebSocketTurboModule) {
     modules.push_back(std::make_unique<CxxNativeModule>(
         m_innerInstance,
         Microsoft::React::GetWebSocketModuleName(),
         [transitionalProps]() { return Microsoft::React::CreateWebSocketModule(transitionalProps); },
         nativeQueue));
+  }
 
+  // Applications using the Windows ABI feature should loade the networking TurboModule variants instead.
+  if (!m_devSettings->omitNetworkingCxxModules) {
     // Use in case the host app provides its a non-Blob-compatilbe HTTP module.
     if (!Microsoft::React::GetRuntimeOptionBool("Blob.DisableModule")) {
       modules.push_back(std::make_unique<CxxNativeModule>(

package/package.json

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