Syncing content from committish 51a9c754ac08c43e58cfaa61726d1dabcb4d9937

Author: reunion-maestro-bot

src/dxaml/xcp/components/imaging/RenderTargetBitmapImplUsingSpriteVisuals.cpp

@@ -30,6 +30,9 @@
 #include <microsoft.ui.composition.internal.h>
 #include <microsoft.ui.composition.internal.interop.h>
 #include <microsoft.ui.composition.private.interop.h>
+#include "FrameworkUdk/Containment.h"
+
+#define WINAPPSDK_CHANGEID_61936248 61936248, WinAppSDK_1_8_8
 
 class CaptureAsyncCompletionState
 {
@@ -115,9 +118,21 @@ RenderTargetBitmapImplUsingSpriteVisuals::PreCommit(
     HWCompTreeNode* elementCompNodeNoRef = m_uiElement->GetCompositionPeer();
     if (elementCompNodeNoRef == nullptr)
     {
-        // The element is being rendered with a LayoutTransitionElement, and doesn't have a comp node. Instead, get the comp node
-        // from the LTE itself. The LTE will contain all the SpriteVisual content in the element's subtree.
-        ASSERT(m_uiElement->IsHiddenForLayoutTransition());
+        if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61936248>())
+        {
+            // The composition peer can be null for reasons other than layout transitions.
+            // Check for an LTE before dereferencing.
+            if (!m_uiElement->IsHiddenForLayoutTransition())
+            {
+                return E_FAIL;
+            }
+        }
+        else
+        {
+            // The element is being rendered with a LayoutTransitionElement, and doesn't have a comp node. Instead, get the comp node
+            // from the LTE itself. The LTE will contain all the SpriteVisual content in the element's subtree.
+            ASSERT(m_uiElement->IsHiddenForLayoutTransition());
+        }
         elementCompNodeNoRef = m_uiElement->GetFirstLTETargetingThis()->GetCompositionPeer();
     }
 

src/dxaml/xcp/core/core/elements/Popup.cpp

@@ -40,6 +40,9 @@
 #include "XamlRoot_Partial.h"
 #include <Microsoft.UI.Composition.h>
 #include <FrameworkUdk/Theming.h>
+#include <FrameworkUdk/Containment.h>
+
+#define WINAPPSDK_CHANGEID_61884734 61884734, WinAppSDK_1_8_8
 #include "WinRTExpressionConversionContext.h"
 #include "VisualDebugTags.h"
 #include "xcpwindow.h"
@@ -1328,6 +1331,27 @@ float CPopup::GetWindowedPopupRasterizationScale() const
     return rasterizationScale;
 }
 
+float CPopup::GetWindowedPopupRootVisualScaleCompensation() const
+{
+    // Windowed popups render in a separate ContentIsland whose RasterizationScale is driven by the system (popup HWND DPI).
+    // For XAML Islands, the effective XamlRoot scale may be overridden (e.g. DesktopWindowXamlSource.OverrideScale).
+    // The main island cancels/adjusts system scale via RootScale. Windowed popups need the same compensation.
+    if (!m_contentIsland)
+    {
+        return 1.0f;
+    }
+
+    const float systemScaleForPopupIsland = GetWindowedPopupRasterizationScale();
+    const float effectiveScaleForPopup = GetEffectiveRootScale();
+
+    if (systemScaleForPopupIsland <= 0.0f || effectiveScaleForPopup <= 0.0f)
+    {
+        return 1.0f;
+    }
+
+    return effectiveScaleForPopup / systemScaleForPopupIsland;
+}
+
 wrl::ComPtr<ixp::IPointerPoint> CPopup::GetPreviousPointerPoint()
 {
     return m_inputSiteAdapter->GetPreviousPointerPoint();
@@ -1627,12 +1651,26 @@ _Check_return_ HRESULT CPopup::PositionAndSizeWindowForWindowedPopup()
         undoY += insets.top;
     }
 
+    float rootScaleCompensation = 1.0f;
+    if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61884734>())
+    {
+        rootScaleCompensation = GetWindowedPopupRootVisualScaleCompensation();
+    }
+
     if (m_contentIslandRootVisual)
     {
         // Set any scale inherited from the ancestor chain
         CMILMatrix rootTransform(true);
-        rootTransform.SetM11(scaleX);
-        rootTransform.SetM22(scaleY);
+        if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61884734>())
+        {
+            rootTransform.SetM11(scaleX * rootScaleCompensation);
+            rootTransform.SetM22(scaleY * rootScaleCompensation);
+        }
+        else
+        {
+            rootTransform.SetM11(scaleX);
+            rootTransform.SetM22(scaleY);
+        }
 
         // Set premultiplied "undo" transform on the window's root visual
         CMILMatrix undo(true);
@@ -1682,11 +1720,26 @@ _Check_return_ HRESULT CPopup::PositionAndSizeWindowForWindowedPopup()
     // Tell the windowed popup inputsite adapter the offset of the popup window from the content
     // root. We do this by using the position passed to MoveAndSize (either earlier in this function
     // or updated by AdjustWindowedPopupBoundsForDropShadow), converted to island coords in dips.
-    wf::Point transformedOffset{
-        PhysicalPixelsToDips(static_cast<float>(m_windowedPopupMoveAndResizeRect.X - rootOffsetPhysical.x)),
-        PhysicalPixelsToDips(static_cast<float>(m_windowedPopupMoveAndResizeRect.Y - rootOffsetPhysical.y))};
+    if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61884734>())
+    {
+        const float popupIslandRasterizationScale = m_contentIsland ? GetWindowedPopupRasterizationScale() : 0.0f;
+        const float offsetXPhysical = static_cast<float>(m_windowedPopupMoveAndResizeRect.X - rootOffsetPhysical.x);
+        const float offsetYPhysical = static_cast<float>(m_windowedPopupMoveAndResizeRect.Y - rootOffsetPhysical.y);
+
+        wf::Point transformedOffset{
+            popupIslandRasterizationScale > 0.0f ? (offsetXPhysical / popupIslandRasterizationScale) : PhysicalPixelsToDips(offsetXPhysical),
+            popupIslandRasterizationScale > 0.0f ? (offsetYPhysical / popupIslandRasterizationScale) : PhysicalPixelsToDips(offsetYPhysical)};
+
+        IFC_RETURN(UpdateTranslationFromContentRoot(transformedOffset, /*forceUpdate*/ false, rootScaleCompensation));
+    }
+    else
+    {
+        wf::Point transformedOffset{
+            PhysicalPixelsToDips(static_cast<float>(m_windowedPopupMoveAndResizeRect.X - rootOffsetPhysical.x)),
+            PhysicalPixelsToDips(static_cast<float>(m_windowedPopupMoveAndResizeRect.Y - rootOffsetPhysical.y))};
 
-    IFC_RETURN(UpdateTranslationFromContentRoot(transformedOffset, /*forceUpdate*/ false));
+        IFC_RETURN(UpdateTranslationFromContentRoot(transformedOffset, /*forceUpdate*/ false));
+    }
 
     // Play the MenuPopupThemeTransition, if we have one
     if (m_animationRootVisual && m_secretTransitionTarget && m_secretTransitionTarget->IsDirty())
@@ -2296,9 +2349,9 @@ HWND CPopup::GetPopupPositioningWindow() const
 }
 
 // Converts between logical and physical pixels
-float CPopup::GetEffectiveRootScale()
+float CPopup::GetEffectiveRootScale() const
 {
-    const auto scale = RootScale::GetRasterizationScaleForElement(this);
+    const auto scale = RootScale::GetRasterizationScaleForElement(const_cast<CPopup*>(this));
     return scale;
 }
 
@@ -2714,7 +2767,7 @@ CPopup::ClearUCRemoveLogicalParentFlag(
 //
 //------------------------------------------------------------------------
 _Check_return_ HRESULT
-CPopup::UpdateTranslationFromContentRoot(const wf::Point& offset, bool forceUpdate)
+CPopup::UpdateTranslationFromContentRoot(const wf::Point& offset, bool forceUpdate, float rootScaleCompensation)
 {
     IFCEXPECT_RETURN(m_inputSiteAdapter);
 
@@ -2725,6 +2778,16 @@ CPopup::UpdateTranslationFromContentRoot(const wf::Point& offset, bool forceUpda
         m_offsetFromMainWindow.X = offset.X;
         m_offsetFromMainWindow.Y = offset.Y;
 
+        // Pointer points for windowed popups are delivered in the coordinate space of the popup's content island.
+        // When DesktopWindowXamlSource.OverrideScale is used, the popup island's rasterization scale (system DPI)
+        // can differ from the XamlRoot effective scale. We compensate the visuals by scaling the island root visual;
+        // mirror that compensation for input by scaling pointer coordinates by the inverse ratio.
+        float inputScaleCompensation = 1.0f;
+        if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61884734>())
+        {
+            inputScaleCompensation = (rootScaleCompensation != 0.0f) ? (1.0f / rootScaleCompensation) : 1.0f;
+        }
+
         auto dxamlCore = DXamlCore::GetCurrent();
         auto coreServices = dxamlCore->GetHandle();
         CREATEPARAMETERS cp(coreServices);
@@ -2734,6 +2797,12 @@ CPopup::UpdateTranslationFromContentRoot(const wf::Point& offset, bool forceUpda
         xref_ptr<CMatrix> matrix;
         xref_ptr<CMatrixTransform> matrixTransform;
 
+        if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61884734>())
+        {
+            matTransform.SetM11(inputScaleCompensation);
+            matTransform.SetM22(inputScaleCompensation);
+        }
+
         IFC_RETURN(CMatrixTransform::Create(reinterpret_cast<CDependencyObject**>(matrixTransform.ReleaseAndGetAddressOf()), &cp));
         IFC_RETURN(CMatrix::Create(reinterpret_cast<CDependencyObject**>(matrix.ReleaseAndGetAddressOf()), &cp));
 

src/dxaml/xcp/core/core/elements/uielement.cpp

@@ -57,6 +57,10 @@
 #include "XStringUtils.h"
 
 #include <CValueBoxer.h>
+#include <rendertargetbitmapmgr.h>
+#include "FrameworkUdk/Containment.h"
+
+#define WINAPPSDK_CHANGEID_61936248 61936248, WinAppSDK_1_8_8
 
 using namespace DirectUI;
 using namespace DCompHelpers;
@@ -1628,6 +1632,21 @@ _Check_return_ HRESULT CUIElement::LeaveImpl(_In_ CDependencyObject *pNamescopeO
     const bool isParentEnabled = params.fCoercedIsEnabled;
     bool alreadyCanceledTransitions = false;
 
+    // If this element is targeted by an RTB, cancel the in-flight render.
+    // The composition peer is about to be removed, and PreCommit would crash
+    // trying to access it.
+    if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61936248>())
+    {
+        if (params.fIsLive && m_isRenderTargetSource)
+        {
+            auto pRTBManager = core->GetRenderTargetBitmapManager();
+            if (pRTBManager != nullptr)
+            {
+                IGNOREHR(pRTBManager->CancelRenderForElement(this));
+            }
+        }
+    }
+
     // If parent is enabled, but local value of IsEnabled is FALSE, need to disable children.
     if (isParentEnabled && !GetIsEnabled())
     {

src/dxaml/xcp/core/dll/rendertargetbitmapmgr.cpp

@@ -8,6 +8,9 @@
 #include <UIThreadScheduler.h>
 #include <D3D11Device.h>
 #include <WindowsGraphicsDeviceManager.h>
+#include "FrameworkUdk/Containment.h"
+
+#define WINAPPSDK_CHANGEID_61936248 61936248, WinAppSDK_1_8_8
 
 //------------------------------------------------------------------------
 //
@@ -521,7 +524,24 @@ CRenderTargetBitmapManager::PreCommit(
                         FALSE /* bSignaled */,
                         FALSE /* bManual */));
 
-                    IFC_RETURN(renderTargetElement->PreCommit(renderTarget, completionEvent));
+                    if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_61936248>())
+                    {
+                        // PreCommit may fail if the target element has left the visual tree
+                        // (e.g., popup closed). Call the outer FailRender to properly transition
+                        // to Idle and complete the async action with an error.
+                        // scope_exit closes the event; no wait was submitted so no hang.
+                        HRESULT preCommitHr = renderTargetElement->PreCommit(renderTarget, completionEvent);
+                        if (FAILED(preCommitHr))
+                        {
+                            IGNOREHR(renderTargetElement->FailRender(preCommitHr));
+                            current = next;
+                            continue;
+                        }
+                    }
+                    else
+                    {
+                        IFC_RETURN(renderTargetElement->PreCommit(renderTarget, completionEvent));
+                    }
 
                     AddWaitItem(renderTargetElement, completionEvent);
 
@@ -956,6 +976,38 @@ CRenderTargetBitmapManager::CountElementJobs(
     return elementJobs;
 }
 
+//------------------------------------------------------------------------
+//
+//  Synopsis:
+//      Cancels RTB operations targeting the given element that have not
+//      yet reached the capture phase (pending and rendering lists only).
+//      RTBs in the drawing list have already completed CaptureAsync and
+//      will finish safely without accessing the element's composition peer.
+//      Called when an element leaves the visual tree (e.g., popup close)
+//      to prevent PreCommit from accessing stale composition state.
+//      Uses IterateList which safely captures 'next' before the callback,
+//      so FailRender can safely modify the list during iteration.
+//
+//------------------------------------------------------------------------
+_Check_return_ HRESULT
+CRenderTargetBitmapManager::CancelRenderForElement(
+    _In_ CUIElement* pElement)
+{
+    auto cancelCallback = [&] (_In_ IRenderTargetElement* element)
+    {
+        if ((element->GetRenderTargetElementData() != nullptr) &&
+            (element->GetRenderTargetElementData()->GetRenderElement() == pElement))
+        {
+            IGNOREHR(element->FailRender(E_ABORT));
+        }
+    };
+
+    IterateList(m_pPendingListNoRef, cancelCallback);
+    IterateList(m_pRenderingListNoRef, cancelCallback);
+
+    return S_OK;
+}
+
 void
 CRenderTargetBitmapManager::EnsureWaitList()
 {

src/dxaml/xcp/core/inc/Popup.h

@@ -119,7 +119,7 @@ class CPopup : public CFrameworkElement
 
     _Check_return_ HRESULT ClearUCRemoveLogicalParentFlag(_In_ CUIElement* pChild);
 
-    _Check_return_ HRESULT UpdateTranslationFromContentRoot(const wf::Point& offset, bool forceUpdate = false);
+    _Check_return_ HRESULT UpdateTranslationFromContentRoot(const wf::Point& offset, bool forceUpdate = false, float rootScaleCompensation = 0.0f);
 
 protected:
     _Check_return_ HRESULT EnterImpl(_In_ CDependencyObject *pNamescopeOwner, _In_ EnterParams params) override;
@@ -447,7 +447,8 @@ class CPopup : public CFrameworkElement
     _Check_return_ HRESULT AdjustWindowedPopupBoundsForDropShadow(_In_ const XRECTF* popupWindowBounds);
     bool ShouldPopupRendersDropShadow() const;
     XTHICKNESS GetInsetsForDropShadow();
-    float GetEffectiveRootScale();
+    float GetEffectiveRootScale() const;
+    float GetWindowedPopupRootVisualScaleCompensation() const;
     float DipsToPhysicalPixels(_In_ float dips);
     float PhysicalPixelsToDips(_In_ float physicalPixels);
     void DipsToPhysicalPixelsRect(_Inout_ XRECTF* rect);

src/dxaml/xcp/core/inc/rendertargetbitmapmgr.h

@@ -90,6 +90,11 @@ class CRenderTargetBitmapManager : public CXcpObjectBase<IObject>
 
     int CountElementJobs(_In_ CUIElement* uiElement);
 
+    // Cancel any in-flight RTB operations targeting this element.
+    // Called when an element leaves the visual tree to prevent PreCommit
+    // from accessing stale composition state.
+    _Check_return_ HRESULT CancelRenderForElement(_In_ CUIElement* pElement);
+
 private:
 
     CRenderTargetBitmapManager(_In_ CCoreServices *pCore);

src/dxaml/xcp/dxaml/lib/UIAffinityReleaseQueue.cpp

@@ -8,6 +8,10 @@
 #include "MUX-ETWEvents.h"
 #include "BuildTreeService.g.h"
 #include "BudgetManager.g.h"
+#include "FrameworkUdk/Containment.h"
+
+// Bug 62097119: [1.8 Servicing][WASDK] Fix re-entrancy crash: PauseDispatch during UIAffinityReleaseQueue::DoCleanup
+#define WINAPPSDK_CHANGEID_62097119 62097119, WinAppSDK_1_8_8
 
 using namespace DirectUI;
 using namespace Instrumentation;
@@ -176,6 +180,20 @@ HRESULT UIAffinityReleaseQueue::DoCleanup( _In_ BOOLEAN bSync, _Out_ BOOLEAN *co
 
 
     // Process objects for final release.
+    //
+    // Pause XAML dispatch during final releases. Object release calls can trigger
+    // cross-apartment COM RPCs (e.g., RemoteReleaseRifRef for proxy teardown),
+    // which enter a COM modal loop that pumps messages via PeekMessage. Without
+    // pausing, CoreMessaging can fire the DispatcherQueueTimer re-entrantly during
+    // the pump, causing a CReentrancyGuard fail-fast in
+    // OnReentrancyProtectedWindowMessage. PauseDispatch sets m_state to Suspended,
+    // which MessageTimerCallback checks before dispatching — preventing the
+    // re-entrant dispatch. ResumeDispatch restarts the timer if there is pending
+    // work, so no messages are lost.
+    if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_62097119>())
+    {
+        DXamlCore::GetCurrent()->PauseDispatchAtControl();
+    }
 
     *completed = TRUE;
     firstRelease = m_queuedObjectsForFinalRelease.begin();
@@ -262,6 +280,13 @@ HRESULT UIAffinityReleaseQueue::DoCleanup( _In_ BOOLEAN bSync, _Out_ BOOLEAN *co
     m_bInCleanup = FALSE;
 
 Cleanup:
+    // Resume dispatch — must happen on all paths (normal and error) to avoid
+    // permanently stalling the dispatcher. Paired with PauseDispatchAtControl above.
+    if (WinAppSdk::Containment::IsChangeEnabled<WINAPPSDK_CHANGEID_62097119>())
+    {
+        DXamlCore::GetCurrent()->ResumeDispatchAtControl();
+    }
+
     TraceReleaseQueueCleanupEnd();
 
     //Telemetry Notify ,UIFinalizer ended