[Windows] Fixed : WebView CanGoBack Returns true when it Shouldn't (#37648)

<!-- Please keep the note below for people who find this PR -->
> [!NOTE]
> Are you waiting for the changes in this PR to be merged?
> It would be very helpful if you could [test the resulting
artifacts](https://github.com/dotnet/maui/wiki/Testing-PR-Builds) from
this PR and let us know in a comment whether this change resolves your
issue. Thank you!

This pull request addresses issues with the accuracy of the `CanGoBack`
and `CanGoForward` properties in the Windows WebView handler, ensuring
that navigation state is correctly reflected and not stale. It also adds
a regression test to prevent future issues with navigation history.

### Description of Change
**Fixes and improvements to WebView navigation state:**

* Updated the logic in `WebViewHandler.Windows.cs` to check
`CoreWebView2.CanGoBack` and `CoreWebView2.CanGoForward` instead of
relying solely on the WebView2 control properties, which could become
stale and cause incorrect navigation behavior.
* Enhanced the `UpdateCanGoBackForward` extension method in
`WebViewExtensions.cs` to prefer the `CoreWebView2` navigation state for
`CanGoBack` and `CanGoForward`, falling back to the control's properties
only when necessary.

**Testing and regression prevention:**

* Added a new test, `CanGoBackIsFalseAfterReturningToFirstPage`, to
verify that `CanGoBack` is set to false after navigating back to the
first page, preventing regressions related to navigation history.


<!-- Enter description of the fix in this section -->

### Issues Fixed

<!-- Please make sure that there is a bug logged for the issue being
fixed. The bug should describe the problem and how to reproduce it. -->

Fixes #37534 

### Tested the behavior in the following platforms

- [x] Windows
- [ ] Android
- [ ] iOS
- [ ] Mac


| Before Issue Fix | After Issue Fix |
|----------|----------|
| <video
src="https://github.com/user-attachments/assets/c6c4e68b-21ac-49cd-ad96-3f628c889674">
| <video
src="https://github.com/user-attachments/assets/1a0fcee7-32d4-42a6-8003-25b89087e580">
|

<!--
Are you targeting main? All PRs should target the main branch unless
otherwise noted.
-->

---------

Author: SubhikshaSf4851

.github/skills/release-readiness/SKILL.md

@@ -144,59 +144,6 @@ preserving their different readiness semantics. It does not read or write Loop
 or SharePoint. Do not copy private source-page content into the evidence file;
 unknown fields must remain `TBD`.
 
-### Preview: local net11 official-build health
-
-For net11 preview runs through this skill from a local checkout, invoke
-`Get-PreviewReadiness.ps1 '-PublicSafe:$false'`. The script then automatically
-queries the internal official `dotnet-maui` pipeline (Azure DevOps definition
-`1095`, org `dnceng`, project `internal`) when the current Azure CLI identity has
-access. No build ID is required. It independently checks:
-
-1. `refs/heads/net11.0` — the inflight source/survey lane.
-2. `refs/heads/release/11.0.1xx-previewN` — the evaluated release branch, when
-   that branch exists.
-
-Candidate mode still checks `net11.0`; it adds the prospective release ref only
-after that ref exists. Identical refs are queried once. The local report includes
-each branch's health classification, build ID and number, pipeline status/result,
-source SHA, and internal build URL. A failed or canceled current build is `red`;
-a partially successful build is `partial-success`; a build behind the newest
-trigger-eligible commit is `stale`; a queued/running build is `in-progress`;
-missing or malformed evidence is `unknown`.
-
-Discovery examines a bounded five-build window. It prefers a build at exact branch
-HEAD, then scans by queue time and skips only candidates proven stale before
-accepting one proven current. Indeterminate candidates are buffered: disagreeing
-possible outcomes remain `unknown`, while a later proven-current failure remains
-`red` only when every buffered candidate is also a completed failure/cancellation.
-A terminal window containing only same-branch failed/canceled indeterminate builds
-also remains blocking as `failed-or-stale` because every candidate is either red
-or stale. Its rendering preserves that uncertainty and requires restoring currency
-evidence before choosing failure repair versus a current-HEAD rerun. This prevents
-both false readiness upgrades and loss of certain blocking evidence.
-
-The internal check is intentionally fail-open:
-
-- `GITHUB_ACTIONS=true` skips it before any Azure command runs.
-- Missing Azure CLI, expired login, or inaccessible dnceng/internal access yields
-  `skipped` and does not downgrade the public-data verdict.
-- Azure CLI and GitHub branch queries have bounded execution; a timeout yields
-  `unknown` rather than hanging the local readiness run.
-- Local `red`/`stale`/`failed-or-stale` maps to `BLOCKED`,
-  `in-progress`/`partial-success` to `WATCH`, and `unknown` to `UNKNOWN`.
-  For `failed-or-stale`, restore build-currency evidence first; then either repair
-  the failed build if it is current or run the official build at current HEAD if
-  it is stale.
-- `-PublicSafe:$true` omits all internal IDs, SHAs, URLs, and branch rows. The
-  public workflow uses this behavior and never receives internal credentials.
-
-The script remains public-safe by default. This skill and the release-readiness
-agent explicitly pass `'-PublicSafe:$false'` for enriched local net11 reports;
-never reuse those artifacts in a public tracker issue. `-IncludeInternal`
-remains an explicit compatibility override when a caller requests a sanitized
-internal classification, and `-InternalBuildId` remains a diagnostic override
-for the evaluated release branch.
-
 ### Preview: authoritative blessed-build source (.NET Release Tracker)
 
 For **Previews**, this skill's public survey (CI health + regression classification on `net<major>.0` or the preview branch) tells you whether the code is *ready*, but it **cannot on its own name which staged build is the official, blessed preview** — that designation lives in the private **.NET Release Tracker** plugin. So when answering *"run release readiness … is net11 preview6 ready?"* / *"which build is the official preview6?"*, consult that authoritative source **in addition to** running `Get-PreviewReadiness.ps1`:

src/Core/src/Handlers/WebView/WebViewHandler.Windows.cs

@@ -104,18 +104,38 @@ internal static void MapBackground(IWebViewHandler handler, IWebView webView)
 
 		public static void MapGoBack(IWebViewHandler handler, IWebView webView, object? arg)
 		{
-			if (handler.PlatformView.CanGoBack && handler is WebViewHandler w)
+			var platformView = handler.PlatformView;
+			if (platformView is null)
+			{
+				return;
+			}
+
+			// Use CoreWebView2.CanGoBack rather than the WebView2 control's CanGoBack,
+			// which can be stale (see UpdateCanGoBackForward).
+			if ((platformView.CoreWebView2?.CanGoBack ?? platformView.CanGoBack) && handler is WebViewHandler w)
+			{
 				w.CurrentNavigationEvent = WebNavigationEvent.Back;
+			}
 
-			handler.PlatformView?.UpdateGoBack(webView);
+			platformView.UpdateGoBack(webView);
 		}
 
 		public static void MapGoForward(IWebViewHandler handler, IWebView webView, object? arg)
 		{
-			if (handler.PlatformView.CanGoForward && handler is WebViewHandler w)
+			var platformView = handler.PlatformView;
+			if (platformView is null)
+			{
+				return;
+			}
+
+			// Use CoreWebView2.CanGoForward rather than the WebView2 control's CanGoForward,
+			// which can be stale (see UpdateCanGoBackForward).
+			if ((platformView.CoreWebView2?.CanGoForward ?? platformView.CanGoForward) && handler is WebViewHandler w)
+			{
 				w.CurrentNavigationEvent = WebNavigationEvent.Forward;
+			}
 
-			handler.PlatformView?.UpdateGoForward(webView);
+			platformView.UpdateGoForward(webView);
 		}
 
 		public static void MapReload(IWebViewHandler handler, IWebView webView, object? arg)

src/Core/src/Platform/Windows/WebViewExtensions.cs

@@ -74,8 +74,10 @@ public static void UpdateUserAgent(this WebView2 platformWebView, IWebView webVi
 
 		public static void UpdateGoBack(this WebView2 platformWebView, IWebView webView)
 		{
-			if (platformWebView == null)
+			if (!platformWebView.IsValid())
+			{
 				return;
+			}
 
 			if (platformWebView.CoreWebView2.CanGoBack)
 				platformWebView.CoreWebView2.GoBack();
@@ -85,8 +87,10 @@ public static void UpdateGoBack(this WebView2 platformWebView, IWebView webView)
 
 		public static void UpdateGoForward(this WebView2 platformWebView, IWebView webView)
 		{
-			if (platformWebView == null)
+			if (!platformWebView.IsValid())
+			{
 				return;
+			}
 
 			if (platformWebView.CoreWebView2.CanGoForward)
 				platformWebView.CoreWebView2.GoForward();
@@ -101,8 +105,21 @@ public static void UpdateReload(this WebView2 platformWebView, IWebView webView)
 
 		internal static void UpdateCanGoBackForward(this WebView2 platformWebView, IWebView webView)
 		{
-			webView.CanGoBack = platformWebView.CanGoBack;
-			webView.CanGoForward = platformWebView.CanGoForward;
+			// The WebView2 XAML control's CanGoBack/CanGoForward properties can become stale
+			// (e.g. remain true even when no history is left), so prefer CoreWebView2's values,
+			// which reflect the current navigation state synchronously. Guard with IsValid()
+			// since CoreWebView2 can throw if accessed after the control has been closed.
+			if (platformWebView.IsValid())
+			{
+				var coreWebView2 = platformWebView.CoreWebView2;
+				webView.CanGoBack = coreWebView2.CanGoBack;
+				webView.CanGoForward = coreWebView2.CanGoForward;
+			}
+			else
+			{
+				webView.CanGoBack = platformWebView.CanGoBack;
+				webView.CanGoForward = platformWebView.CanGoForward;
+			}
 		}
 
 		public static void Eval(this WebView2 platformWebView, IWebView webView, string script)

src/Core/tests/DeviceTests/Handlers/WebView/WebViewHandlerTests.Windows.cs

@@ -328,8 +328,6 @@ await InvokeOnMainThreadAsync(async () =>
 
 				var handler = CreateHandler(webView);
 
-				var platformView = handler.PlatformView;
-
 				// Setup the view to be displayed/parented and run our tests on it
 				await AttachAndRun(webView, async (handler) =>
 				{
@@ -388,6 +386,71 @@ await AttachAndRun(webView, async (handler) =>
 			});
 		}
 
+		[Fact(DisplayName = "CanGoBack Is False After Navigating Back To The First Page (Issue #37534)")]
+		public async Task CanGoBackIsFalseAfterReturningToFirstPage()
+		{
+			var pageLoadTimeout = TimeSpan.FromSeconds(5);
+
+			await InvokeOnMainThreadAsync(async () =>
+			{
+				var webView = new WebViewStub()
+				{
+					Width = 100,
+					Height = 100,
+					Source = new HtmlWebViewSourceStub { Html = "<h1>Page 1</h1>" }
+				};
+
+				var handler = CreateHandler(webView);
+
+				var platformView = handler.PlatformView;
+
+				// Setup the view to be displayed/parented and run our tests on it
+				await AttachAndRun(webView, async (handler) =>
+				{
+					async Task WaitForNavigationAsync(Action navigate)
+					{
+						var tcsNavigated = new TaskCompletionSource<bool>();
+						using var ctsTimeout = new CancellationTokenSource(pageLoadTimeout);
+						ctsTimeout.Token.Register(() => tcsNavigated.TrySetException(new TimeoutException("Failed to navigate")));
+
+						webView.NavigatedDelegate = (evnt, url, result) =>
+						{
+							if (result == WebNavigationResult.Success)
+								tcsNavigated.TrySetResult(true);
+						};
+
+						navigate();
+
+						Assert.True(await tcsNavigated.Task);
+					}
+
+					// Wait for the first page to finish loading
+					await WaitForNavigationAsync(() => { });
+
+					// Navigate to a second page, creating back history
+					await WaitForNavigationAsync(() =>
+					{
+						webView.Source = new HtmlWebViewSourceStub { Html = "<h1>Page 2</h1>" };
+						handler.UpdateValue(nameof(IWebView.Source));
+					});
+
+					Assert.True(webView.CanGoBack, "CanGoBack should be true after navigating to a second page.");
+
+					// Navigate back to the first page
+					await WaitForNavigationAsync(() =>
+					{
+						handler.Invoke(nameof(IWebView.GoBack), null);
+					});
+
+					// Regression test for https://github.com/dotnet/maui/issues/37534:
+					// CanGoBack should become false once there is no more back history left,
+					// instead of remaining stale as true (which caused GoBack() to repeatedly
+					// reload the same page instead of falling back to app-level navigation).
+					Assert.False(webView.CanGoBack, "CanGoBack should be false once there is no more back history.");
+				});
+			});
+		}
+
 		WebView2 GetNativeWebView(WebViewHandler webViewHandler) =>
 			webViewHandler.PlatformView;