[Windows] Fixed BoxView improper rendering inside Border (#28465)

### Issue Details:
Placing a BoxView inside a Border results in incorrect sizing.

### Root Cause
On Windows, when content inside a Border has the same or larger explicit
size than the Border itself, the WinUI AdjustForExplicitSize logic
expands the content's measured size back to its requested dimensions,
even after the available size has been reduced to account for the border
stroke. This causes MeasureContent to return a desired size larger than
the Border by StrokeThickness * 2, resulting in the parent layout
allocating an oversized layout slot. Consequently, the right and bottom
border strokes can be clipped during rendering.

### Description of Change
Override MeasureOverride in the Windows ContentPanel to constrain the
reported desired size to the Border's explicit Width and Height when
both values are set. This ensures the correct desired size is returned
to the parent layout, allowing the Border to receive the intended layout
slot size while preserving the existing ArrangeOverride and clipping
behavior.

### Validated the behaviour in the following platforms
 
- [x] Android
- [x] Windows
- [x] iOS
- [x] Mac
 
### Issues Fixed:
Fixes #19668 
 
### Screenshots
| Before  | After  |
|---------|--------|
| <img
src="https://github.com/user-attachments/assets/b81f0982-e3c2-40d9-ab8b-0b1d743fa99a">
| <img
src="https://github.com/user-attachments/assets/f45e3ebf-e48c-48dd-9c39-42c5413c9268">
|

Author: Dhivya-SF4094

src/Controls/tests/DeviceTests/Elements/Border/BorderTests.Windows.cs

@@ -1,9 +1,12 @@
-using System.ComponentModel;
+using System;
+using System.ComponentModel;
 using System.Threading.Tasks;
 using Microsoft.Maui.Controls;
+using Microsoft.Maui.Controls.Handlers;
 using Microsoft.Maui.Controls.Shapes;
 using Microsoft.Maui.Graphics;
 using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Hosting;
 using Microsoft.Maui.Platform;
 using Microsoft.UI.Composition;
 using Microsoft.UI.Xaml.Automation.Peers;
@@ -79,6 +82,89 @@ await InvokeOnMainThreadAsync(() =>
 			   });
 		}
 
+		[Fact(DisplayName = "Border should not expand beyond its requested size when BoxView content is larger - Issue 19668")]
+		public async Task BorderShouldNotExpandBeyondRequestedSizeWithBoxViewContent()
+		{
+			EnsureHandlerCreated(builder =>
+			{
+				builder.ConfigureMauiHandlers(handlers =>
+	   {
+				 handlers.AddHandler<Border, BorderHandler>();
+				 handlers.AddHandler<BoxView, BoxViewHandler>();
+			 });
+			});
+
+			// BoxView is intentionally LARGER than the Border's requested size.
+			// The bug: the BoxView pushes the Border to expand beyond its WidthRequest/HeightRequest.
+			// The fix: the Border must constrain itself to its requested size regardless of content.
+			var boxView = new BoxView
+			{
+				Color = Colors.Red,
+				WidthRequest = 120,
+				HeightRequest = 120,
+			};
+
+			var border = new Border
+			{
+				BackgroundColor = Colors.Blue,
+				WidthRequest = 80,
+				HeightRequest = 80,
+				Content = boxView
+			};
+
+			// GetRawBitmap dimensions reflect the actual rendered size of the Border.
+			// With bug:   Border expands to fit BoxView → bitmap is ~120x120 → assertions FAIL.
+			// After fix:  Border stays at requested size → bitmap is 80x80 → assertions PASS.
+			var bitmap = await GetRawBitmap(border, typeof(BorderHandler)).WaitAsync(TimeSpan.FromSeconds(5));
+
+			Assert.Equal(80, bitmap.Width, 2d);
+			Assert.Equal(80, bitmap.Height, 2d);
+		}
+
+		[Fact(DisplayName = "Border with stroke should not inflate measured size when Label content has same explicit dimensions - Issue 19668")]
+		public async Task BorderWithStrokeShouldNotInflateMeasuredSizeWhenLabelHasSameExplicitDimensions()
+		{
+			EnsureHandlerCreated(builder =>
+			{
+				builder.ConfigureMauiHandlers(handlers =>
+				{
+					handlers.AddHandler<Border, BorderHandler>();
+					handlers.AddHandler<Label, LabelHandler>();
+				});
+			});
+
+			// The root cause of #19668: when content has the SAME WidthRequest/HeightRequest as the
+			// Border, AdjustForExplicitSize re-expands the content's measured size back to its
+			// explicit request even after the stroke inset has reduced the available constraint.
+			// This inflates MeasureContent's result by StrokeThickness*2, causing the parent to
+			// allocate an oversized slot so the border's right/bottom strokes get clipped.
+			const double requestedSize = 100;
+			const double strokeThickness = 4;
+
+			var label = new Label
+			{
+				Text = "Hello",
+				WidthRequest = requestedSize,
+				HeightRequest = requestedSize,
+			};
+
+			var border = new Border
+			{
+				BackgroundColor = Colors.Blue,
+				WidthRequest = requestedSize,
+				HeightRequest = requestedSize,
+				StrokeThickness = strokeThickness,
+				Content = label
+			};
+
+			// With bug:   desired size = requestedSize + StrokeThickness*2 → bitmap is ~108x108.
+			// After fix:  desired size capped at requestedSize → bitmap is 100x100.
+			var bitmap = await GetRawBitmap(border, typeof(BorderHandler)).WaitAsync(TimeSpan.FromSeconds(5));
+
+			Assert.Equal(requestedSize, bitmap.Width, 2d);
+			Assert.Equal(requestedSize, bitmap.Height, 2d);
+		}
+
 		ContentPanel GetNativeBorder(BorderHandler borderHandler) =>
 			borderHandler.PlatformView;
 

src/Controls/tests/TestCases.WinUI.Tests/snapshots/windows/EditorScrollingWhenEnclosedInBorder.png

@@ -8,10 +8,12 @@
 #else
 using Microsoft.Maui.Graphics.Platform;
 #endif
+using Microsoft.Maui.Primitives;
 using Microsoft.UI.Composition;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Automation;
 using Microsoft.UI.Xaml.Automation.Peers;
+using Microsoft.UI.Xaml.Controls.Primitives;
 using Microsoft.UI.Xaml.Hosting;
 using Microsoft.UI.Xaml.Shapes;
 using Microsoft.UI.Xaml.Media;
@@ -55,6 +57,37 @@ internal FrameworkElement? Content
 
 		internal bool IsInnerPath { get; private set; }
 
+		protected override global::Windows.Foundation.Size MeasureOverride(global::Windows.Foundation.Size availableSize)
+		{
+			var measured = base.MeasureOverride(availableSize);
+
+			// On Windows, when content inside a Border has the same WidthRequest/HeightRequest
+			// as the Border itself, AdjustForExplicitSize expands the content's measured size
+			// back to its explicit request even after the stroke inset reduces the constraint.
+			// This inflates MeasureContent's result by StrokeThickness*2, so the parent
+			// allocates an oversized layout slot and the border renders with its right/bottom
+			// strokes clipped. Capping here at the Border's explicit dimensions corrects the
+			// reported desired size and ensures the parent allocates the right amount.
+			if (_borderStroke is not null && Content is not null &&
+			 CrossPlatformLayout is IBorderView borderView)
+			{
+				var explicitWidth = borderView.Width;
+				var explicitHeight = borderView.Height;
+
+				if (Dimension.IsExplicitSet(explicitWidth))
+				{
+					measured.Width = Math.Min(measured.Width, explicitWidth);
+				}
+
+				if (Dimension.IsExplicitSet(explicitHeight))
+				{
+					measured.Height = Math.Min(measured.Height, explicitHeight);
+				}
+			}
+
+			return measured;
+		}
+
 		protected override global::Windows.Foundation.Size ArrangeOverride(global::Windows.Foundation.Size finalSize)
 		{
 			var actual = base.ArrangeOverride(finalSize);
@@ -66,7 +99,7 @@ internal FrameworkElement? Content
 			// We need to update the clip since the content's position might have changed
 			UpdateClip(_borderStroke?.Shape, size.Width, size.Height);
 
-			return size;
+			return actual;
 		}
 
 		protected override AutomationPeer OnCreateAutomationPeer()
@@ -251,8 +284,11 @@ void UpdateClip(IShape? borderShape, double width, double height)
 			var pathGeometry = compositor.CreatePathGeometry(path);
 			var geometricClip = compositor.CreateGeometricClip(pathGeometry);
 
-			// The clip needs to consider the content's offset in case it is in a different position because of a different alignment.
-			geometricClip.Offset = new Vector2(strokeThickness - Content.ActualOffset.X, strokeThickness - Content.ActualOffset.Y);
+			// The clip needs to consider the content's layout slot position, using GetLayoutSlot for
+			// a synchronous arrange-time value rather than the composition ActualOffset which can
+			// lag behind and produce an incorrect offset on the first layout pass.
+			var layoutSlot = LayoutInformation.GetLayoutSlot(Content);
+			geometricClip.Offset = new Vector2(strokeThickness - (float)layoutSlot.X, strokeThickness - (float)layoutSlot.Y);
 
 			visual.Clip = geometricClip;
 		}

src/Controls/tests/TestCases.WinUI.Tests/snapshots/windows/VerifyImageAspect_AspectFitWithImageSourceFromUri.png

@@ -1,4 +1,5 @@
 #nullable enable
 override Microsoft.Maui.Platform.LayoutPanel.OnCreateAutomationPeer() -> Microsoft.UI.Xaml.Automation.Peers.AutomationPeer!
 override Microsoft.Maui.Platform.MauiPasswordTextBox.OnCreateAutomationPeer() -> Microsoft.UI.Xaml.Automation.Peers.AutomationPeer!
+override Microsoft.Maui.Platform.ContentPanel.MeasureOverride(Windows.Foundation.Size availableSize) -> Windows.Foundation.Size
 override Microsoft.Maui.Platform.ContentPanel.OnCreateAutomationPeer() -> Microsoft.UI.Xaml.Automation.Peers.AutomationPeer!