react-native-windows 0.0.0-canary.575 → 0.0.0-canary.577

package/Microsoft.ReactNative/INativeUIManager.h

@@ -50,6 +50,7 @@ struct INativeUIManager {
   virtual void UpdateView(ShadowNode &shadowNode, winrt::Microsoft::ReactNative::JSValueObject &props) = 0;
   virtual void onBatchComplete() = 0;
   virtual void ensureInBatch() = 0;
+  virtual bool isInBatch() = 0;
   virtual void measure(
       ShadowNode &shadowNode,
       ShadowNode &shadowRoot,

package/Microsoft.ReactNative/LayoutService.cpp

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "LayoutService.h"
+#include "LayoutService.g.cpp"
+#include <Modules/NativeUIManager.h>
+#include <Modules/PaperUIManagerModule.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+LayoutService::LayoutService(Mso::CntPtr<Mso::React::IReactContext> &&context) noexcept : m_context(context) {}
+
+/*static*/ winrt::Microsoft::ReactNative::LayoutService LayoutService::FromContext(IReactContext context) {
+  return context.Properties()
+      .Get(LayoutService::LayoutServiceProperty().Handle())
+      .try_as<winrt::Microsoft::ReactNative::LayoutService>();
+}
+
+/*static*/ ReactPropertyId<LayoutService> LayoutService::LayoutServiceProperty() noexcept {
+  static ReactPropertyId<LayoutService> layoutServiceProperty{L"ReactNative.UIManager", L"LayoutService"};
+  return layoutServiceProperty;
+}
+
+void LayoutService::ApplyLayoutForAllNodes() noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    uiManager->DoLayout();
+  }
+}
+
+void LayoutService::ApplyLayout(int64_t reactTag, float width, float height) noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    uiManager->ApplyLayout(reactTag, width, height);
+  }
+}
+
+bool LayoutService::IsInBatch() noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    return uiManager->isInBatch();
+  }
+
+  return false;
+}
+
+void LayoutService::MarkDirty(int64_t reactTag) noexcept {
+  if (auto uiManager = ::Microsoft::ReactNative::GetNativeUIManager(*m_context).lock()) {
+    uiManager->DirtyYogaNode(reactTag);
+  }
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/LayoutService.h

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "LayoutService.g.h"
+#include "INativeUIManager.h"
+#include "ReactHost/React.h"
+#include "ReactPropertyBag.h"
+#include "winrt/Microsoft.ReactNative.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+struct LayoutService : LayoutServiceT<LayoutService> {
+ public:
+  LayoutService(Mso::CntPtr<Mso::React::IReactContext> &&context) noexcept;
+  static winrt::Microsoft::ReactNative::LayoutService FromContext(IReactContext context);
+  static ReactPropertyId<LayoutService> LayoutServiceProperty() noexcept;
+
+  void ApplyLayoutForAllNodes() noexcept;
+  void ApplyLayout(int64_t reactTag, float width, float height) noexcept;
+  bool IsInBatch() noexcept;
+  void MarkDirty(int64_t reactTag) noexcept;
+
+ private:
+  Mso::CntPtr<Mso::React::IReactContext> m_context;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation
+
+namespace winrt::Microsoft::ReactNative::factory_implementation {
+struct LayoutService : LayoutServiceT<LayoutService, implementation::LayoutService> {};
+} // namespace winrt::Microsoft::ReactNative::factory_implementation

package/Microsoft.ReactNative/LayoutService.idl

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import "IReactContext.idl";
+
+#include "NamespaceRedirect.h"
+#include "DocString.h"
+
+namespace Microsoft.ReactNative
+{
+  [default_interface]
+  [webhosthidden]
+  DOC_STRING("Provides access to Yoga layout functionality.")
+  runtimeclass LayoutService {
+    DOC_STRING("Use this method to get access to the @LayoutService associated with the @IReactContext.")
+    static LayoutService FromContext(IReactContext context);
+
+    DOC_STRING(
+      "Recursively applies layout to all root nodes. This method will trigger "
+      "a Yoga layout operation on roots attached to the React instance and "
+      "apply the layout results to all descendant nodes.")
+    void ApplyLayoutForAllNodes();
+
+    DOC_STRING(
+      "Recursively applies layout from the given React node with the supplied "
+      "size constraints. This method will trigger a Yoga layout operation on the "
+      "given node and its descendants and apply the layout results to these nodes.")
+    void ApplyLayout(Int64 reactTag, Single width, Single height);
+
+    DOC_STRING(
+        "Determines whether the UIManager is currently processing a batch of node updates."
+        "This is useful for optimizing layout and ensuring that applying layout to a particular "
+        "node will not cause tearing in the rendered UI.")
+    Boolean IsInBatch {
+      get;
+    };
+
+    DOC_STRING("Mark a particular React node as dirty for Yoga layout.")
+    void MarkDirty(Int64 reactTag);
+  }
+} // namespace ReactNative

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj

@@ -380,6 +380,10 @@
     <ClInclude Include="Views\VirtualTextViewManager.h" />
     <ClInclude Include="Views\XamlFeatures.h" />
     <ClInclude Include="XamlLoadState.h" />
+    <ClInclude Include="LayoutService.h">
+      <DependentUpon>LayoutService.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClInclude>
     <ClInclude Include="XamlUIService.h">
       <DependentUpon>XamlUIService.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -598,6 +602,10 @@
     <ClCompile Include="Views\XamlFeatures.cpp" />
     <ClCompile Include="XamlLoadState.cpp" />
     <ClCompile Include="XamlView.cpp" />
+    <ClCompile Include="LayoutService.cpp">
+      <DependentUpon>LayoutService.idl</DependentUpon>
+      <SubType>Code</SubType>
+    </ClCompile>
     <ClCompile Include="XamlUIService.cpp">
       <DependentUpon>XamlUIService.idl</DependentUpon>
       <SubType>Code</SubType>
@@ -674,6 +682,9 @@
     <Midl Include="Views\cppwinrt\Effects.idl" />
     <Midl Include="Views\cppwinrt\DynamicAutomationPeer.idl" />
     <Midl Include="Views\cppwinrt\ViewPanel.idl" />
+    <Midl Include="LayoutService.idl">
+      <SubType>Designer</SubType>
+    </Midl>
     <Midl Include="XamlUIService.idl">
       <SubType>Designer</SubType>
     </Midl>
@@ -781,4 +792,4 @@
       </ClCompile>
     </ItemGroup>
   </Target>
-</Project>
+</Project>

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj.filters

@@ -752,6 +752,7 @@
     <Midl Include="RedBoxHandler.idl" />
     <Midl Include="QuirkSettings.idl" />
     <Midl Include="XamlHelper.idl" />
+    <Midl Include="LayoutService.idl" />
     <Midl Include="XamlUIService.idl" />
     <Midl Include="Views\cppwinrt\AccessibilityAction.idl">
       <Filter>Views\cppwinrt</Filter>
@@ -827,4 +828,4 @@
     <Page Include="DevMenuControl.xaml" />
     <Page Include="CoreAppPage.xaml" />
   </ItemGroup>
-</Project>
+</Project>

package/Microsoft.ReactNative/Modules/NativeUIManager.cpp

@@ -260,6 +260,10 @@ void NativeUIManager::ensureInBatch() {
     m_inBatch = true;
 }
 
+bool NativeUIManager::isInBatch() {
+  return m_inBatch;
+}
+
 static float NumberOrDefault(const winrt::Microsoft::ReactNative::JSValue &value, float defaultValue) {
   float result = defaultValue;
 
@@ -884,28 +888,28 @@ void NativeUIManager::DoLayout() {
   auto &rootTags = m_host->GetAllRootTags();
   for (int64_t rootTag : rootTags) {
     ShadowNodeBase &rootShadowNode = static_cast<ShadowNodeBase &>(m_host->GetShadowNodeForTag(rootTag));
-    if (YGNodeRef rootNode = GetYogaNode(rootTag)) {
-      auto rootElement = rootShadowNode.GetView().as<xaml::FrameworkElement>();
-
-      float actualWidth = static_cast<float>(rootElement.ActualWidth());
-      float actualHeight = static_cast<float>(rootElement.ActualHeight());
-
-      {
-        SystraceSection s("NativeUIManager::DoLayout::YGNodeCalculateLayout");
-        // We must always run layout in LTR mode, which might seem unintuitive.
-        // We will flip the root of the tree into RTL by forcing the root XAML node's FlowDirection to RightToLeft
-        // which will inherit down the XAML tree, allowing all native controls to pick it up.
-        YGNodeCalculateLayout(rootNode, actualWidth, actualHeight, YGDirectionLTR);
-      }
-    } else {
-      assert(false);
-      return;
-    }
+    const auto rootElement = rootShadowNode.GetView().as<xaml::FrameworkElement>();
+    float actualWidth = static_cast<float>(rootElement.ActualWidth());
+    float actualHeight = static_cast<float>(rootElement.ActualHeight());
+    ApplyLayout(rootTag, actualWidth, actualHeight);
+  }
+}
 
-    {
-      SystraceSection s("NativeUIManager::DoLayout::SetLayoutProps");
-      SetLayoutPropsRecursive(rootTag);
-    }
+void NativeUIManager::ApplyLayout(int64_t tag, float width, float height) {
+  if (YGNodeRef rootNode = GetYogaNode(tag)) {
+    SystraceSection s("NativeUIManager::DoLayout::YGNodeCalculateLayout");
+    // We must always run layout in LTR mode, which might seem unintuitive.
+    // We will flip the root of the tree into RTL by forcing the root XAML node's FlowDirection to RightToLeft
+    // which will inherit down the XAML tree, allowing all native controls to pick it up.
+    YGNodeCalculateLayout(rootNode, width, height, YGDirectionLTR);
+  } else {
+    assert(false);
+    return;
+  }
+
+  {
+    SystraceSection s("NativeUIManager::DoLayout::SetLayoutProps");
+    SetLayoutPropsRecursive(tag);
   }
 }
 
@@ -1132,9 +1136,9 @@ void NativeUIManager::focus(int64_t reactTag) {
 // Note: It's a known issue that blur on flyout/popup would dismiss them.
 void NativeUIManager::blur(int64_t reactTag) {
   if (auto shadowNode = static_cast<ShadowNodeBase *>(m_host->FindShadowNodeForTag(reactTag))) {
-    auto view = shadowNode->GetView();
     // Only blur if current UI is focused to avoid problem described in PR #2687
-    if (view == xaml::Input::FocusManager::GetFocusedElement().try_as<xaml::DependencyObject>()) {
+    const auto xamlRoot = tryGetXamlRoot(shadowNode->m_rootTag);
+    if (shadowNode->GetView() == xaml::Input::FocusManager::GetFocusedElement(xamlRoot)) {
       if (auto reactControl = GetParentXamlReactControl(reactTag).get()) {
         reactControl.as<winrt::Microsoft::ReactNative::implementation::ReactRootView>()->blur(shadowNode->GetView());
       } else {

package/Microsoft.ReactNative/Modules/NativeUIManager.h

@@ -56,6 +56,7 @@ class NativeUIManager final : public INativeUIManager {
   void UpdateView(ShadowNode &shadowNode, winrt::Microsoft::ReactNative::JSValueObject &props) override;
   void onBatchComplete() override;
   void ensureInBatch() override;
+  bool isInBatch() override;
   void measure(
       ShadowNode &shadowNode,
       ShadowNode &shadowRoot,
@@ -100,8 +101,10 @@ class NativeUIManager final : public INativeUIManager {
 
   int64_t AddMeasuredRootView(facebook::react::IReactRootView *rootView);
 
- private:
   void DoLayout();
+  void ApplyLayout(int64_t tag, float width = YGUndefined, float height = YGUndefined);
+
+ private:
   void SetLayoutPropsRecursive(int64_t tag);
   YGNodeRef GetYogaNode(int64_t tag) const;
 

package/Microsoft.ReactNative/ReactHost/ReactInstanceWin.cpp

@@ -12,6 +12,7 @@
 #include <appModel.h>
 #include <comUtil/qiCast.h>
 #ifndef CORE_ABI
+#include <LayoutService.h>
 #include <XamlUIService.h>
 #endif
 #include "ReactErrorProvider.h"
@@ -762,6 +763,10 @@ void ReactInstanceWin::InitUIManager() noexcept {
   m_reactContext->Properties().Set(
       implementation::XamlUIService::XamlUIServiceProperty().Handle(),
       winrt::make<implementation::XamlUIService>(m_reactContext));
+
+  m_reactContext->Properties().Set(
+      implementation::LayoutService::LayoutServiceProperty().Handle(),
+      winrt::make<implementation::LayoutService>(m_reactContext));
 }
 #endif
 

package/Microsoft.ReactNative/Views/ScrollViewManager.cpp

@@ -90,8 +90,7 @@ void ScrollViewShadowNode::dispatchCommand(
     scrollViewer.ChangeView(x, y, nullptr, !animated /*disableAnimation*/);
   } else if (commandId == ScrollViewCommands::ScrollToEnd) {
     bool animated = commandArgs[0].AsBoolean();
-    bool horiz = scrollViewer.HorizontalScrollMode() == winrt::ScrollMode::Auto;
-    if (horiz)
+    if (m_isHorizontal)
       scrollViewer.ChangeView(scrollViewer.ScrollableWidth(), nullptr, nullptr, !animated /*disableAnimation*/);
     else
       scrollViewer.ChangeView(nullptr, scrollViewer.ScrollableHeight(), nullptr, !animated /*disableAnimation*/);
@@ -490,7 +489,6 @@ XamlView ScrollViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microso
   scrollViewer.VerticalSnapPointsAlignment(winrt::SnapPointsAlignment::Near);
   scrollViewer.VerticalSnapPointsType(winrt::SnapPointsType::Mandatory);
   scrollViewer.HorizontalSnapPointsType(winrt::SnapPointsType::Mandatory);
-  scrollViewer.HorizontalScrollMode(winrt::ScrollMode::Disabled);
 
   const auto snapPointManager = SnapPointManagingContentControl::Create();
   scrollViewer.Content(*snapPointManager);

package/Microsoft.ReactNative/Views/Text/TextPropertyChangedParentVisitor.cpp

@@ -40,13 +40,7 @@ void TextPropertyChangedParentVisitor::VisitText(ShadowNodeBase *node) {
       }
     }
 
-    // Update fast text content
-    if (!m_isNested && node->m_children.size() == 1) {
-      if (const auto childNode = GetShadowNode(node->m_children[0])) {
-        const auto run = static_cast<ShadowNodeBase *>(childNode)->GetView().as<winrt::Run>();
-        element.Text(run.Text());
-      }
-    }
+    TextViewManager::UpdateOptimizedText(node);
   }
 
   // Refresh text highlighters

package/Microsoft.ReactNative/Views/TextViewManager.cpp

@@ -39,8 +39,7 @@ class TextShadowNode final : public ShadowNodeBase {
   friend TextViewManager;
 
  private:
-  ShadowNode *m_firstChildNode;
-
+  bool m_isTextOptimized{true};
   bool m_hasDescendantTextHighlighter{false};
   bool m_hasDescendantPressable{false};
   std::optional<winrt::Windows::UI::Color> m_backgroundColor{};
@@ -49,9 +48,6 @@ class TextShadowNode final : public ShadowNodeBase {
   winrt::event_revoker<xaml::Controls::ITextBlock> m_selectionChangedRevoker;
 
  public:
-  TextShadowNode() {
-    m_firstChildNode = nullptr;
-  };
   bool ImplementsPadding() override {
     return true;
   }
@@ -66,25 +62,23 @@ class TextShadowNode final : public ShadowNodeBase {
       m_hasDescendantPressable |= textChildNode.hasDescendantPressable;
     }
 
-    auto addInline = true;
-    // Only convert to fast text when exactly one child is attached to the root Text node
-    if (index == 0 && m_children.size() == 1) {
-      auto run = childNode.GetView().try_as<winrt::Run>();
-      if (run != nullptr) {
-        m_firstChildNode = &child;
-        auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-        textBlock.Text(run.Text());
-        addInline = false;
+    const auto wasOptimized = m_isTextOptimized;
+    m_isTextOptimized = IsRawTextShadowNode(&childNode) && m_isTextOptimized;
+    if (m_isTextOptimized) {
+      // Re-build optimized text from children
+      UpdateOptimizedText();
+    } else if (wasOptimized) {
+      // Remove optimized text and re-construct as Inline tree
+      UpdateOptimizedText();
+      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+        for (size_t i = 0; i < m_children.size(); ++i) {
+          if (const auto childNode =
+                  static_cast<ShadowNodeBase *>(uiManager->getHost()->FindShadowNodeForTag(m_children[i]))) {
+            Super::AddView(*childNode, i);
+          }
+        }
       }
-    } else if (m_firstChildNode != nullptr) {
-      assert(m_children.size() == 2);
-      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-      Super::AddView(*m_firstChildNode, 0);
-      m_firstChildNode = nullptr;
-    }
-
-    if (addInline) {
+    } else {
       Super::AddView(child, index);
     }
 
@@ -92,10 +86,9 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void removeAllChildren() override {
-    if (m_firstChildNode) {
+    if (m_isTextOptimized) {
       auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
       textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-      m_firstChildNode = nullptr;
     } else {
       Super::removeAllChildren();
     }
@@ -103,17 +96,33 @@ class TextShadowNode final : public ShadowNodeBase {
   }
 
   void RemoveChildAt(int64_t indexToRemove) override {
-    if (m_firstChildNode) {
-      assert(indexToRemove == 0);
-      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-      m_firstChildNode = nullptr;
+    if (m_isTextOptimized) {
+      UpdateOptimizedText();
     } else {
       Super::RemoveChildAt(indexToRemove);
     }
     RecalculateTextHighlighters();
   }
 
+  void UpdateOptimizedText() {
+    if (m_children.size() > 0 && m_isTextOptimized) {
+      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
+        winrt::hstring text = L"";
+        for (const auto childTag : m_children) {
+          if (const auto childNode =
+                  static_cast<ShadowNodeBase *>(uiManager->getHost()->FindShadowNodeForTag(childTag))) {
+            text = text + childNode->GetView().as<winrt::Run>().Text();
+          }
+        }
+        auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
+        textBlock.Text(text);
+      }
+    } else {
+      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
+      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
+    }
+  }
+
   void RecalculateTextHighlighters() {
     const auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
     textBlock.TextHighlighters().Clear();
@@ -389,6 +398,13 @@ void TextViewManager::OnPointerEvent(
   }
 }
 
+/*static*/ void TextViewManager::UpdateOptimizedText(ShadowNodeBase *node) {
+  if (IsTextShadowNode(node)) {
+    const auto textNode = static_cast<TextShadowNode *>(node);
+    textNode->UpdateOptimizedText();
+  }
+}
+
 /*static*/ void TextViewManager::SetDescendantPressable(ShadowNodeBase *node) {
   if (IsTextShadowNode(node)) {
     const auto textNode = static_cast<TextShadowNode *>(node);

package/Microsoft.ReactNative/Views/TextViewManager.h

@@ -29,6 +29,8 @@ class TextViewManager : public FrameworkElementViewManager {
 
   static void UpdateTextHighlighters(ShadowNodeBase *node, bool highlightAdded);
 
+  static void UpdateOptimizedText(ShadowNodeBase *node);
+
   static void SetDescendantPressable(ShadowNodeBase *node);
 
   static TextTransform GetTextTransformValue(ShadowNodeBase *node);

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,7 +10,7 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.0.0-canary.575</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.0.0-canary.577</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>0</ReactNativeWindowsMinor>
     <ReactNativeWindowsPatch>0</ReactNativeWindowsPatch>

package/Shared/Networking/WinRTHttpResource.cpp

@@ -53,6 +53,34 @@ using winrt::Windows::Web::Http::Headers::HttpMediaTypeHeaderValue;
 
 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 +109,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 +134,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 +177,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;
     }
   }
 
@@ -316,11 +369,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());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.0.0-canary.575",
+  "version": "0.0.0-canary.577",
   "license": "MIT",
   "repository": {
     "type": "git",