Fix wasm Playwright TargetClosedException caused by wrong Helix queue (#125548)

## Summary

Fixes #121195

Wasm Playwright browser tests fail intermittently with
`TargetClosedException`. Investigation revealed **two distinct failure
modes**:

### Root Cause 1: Wrong Helix queue for internal builds

In `eng/pipelines/libraries/helix-queues-setup.yml`, the Android queue
selection used an `or` condition:

```yaml
- ${{ if or(eq(variables['System.TeamProject'], 'internal'), in(parameters.platform, 'android_x86', ...)) }}:
  - Ubuntu.2204.Amd64.Android.29.Open
```

For internal builds, `System.TeamProject == 'internal'` is always true,
so the Android queue was added for **all platforms** — including
`browser_wasm`. This caused wasm browser tests to run on both:
- ✅ `ubuntu-22.04-helix-webassembly` Docker container (has Chrome shared
lib deps → tests pass)
- ❌ `ubuntu.2204.amd64.android.29` bare metal (missing `libgbm.so.1` →
Chrome can't start → `TargetClosedException`)

**Evidence:** Internal build 2920781 log: `Using Queues:
ubuntu.2204.amd64.android.29+(ubuntu.2204.amd64)ubuntu.2204.amd64@mcr.microsoft.com/...ubuntu-22.04-helix-webassembly`

### Root Cause 2: Intermittent Chrome OOM crash on public builds

Public builds use only the correct Docker queue (with Chrome deps), but
Chrome still crashes intermittently. Investigation of build 1332440
showed:
- Chrome launches successfully, then silently dies during `GotoAsync`
navigation
- No missing library errors, no crash output — Chrome is OOM-killed
- xunit runs test classes **in parallel** (default behavior,
`CollectionPerAssembly` is commented out)
- Concurrent Chrome instances + `wasm-opt` builds exhaust Docker
container memory
- The existing retry in `SpawnBrowserAsync` only covers `LaunchAsync`,
not navigation

**Evidence:** Build 1332440, job ff40a660 — `SatelliteLoadingTests`
Chrome crashes while `AssetCachingTests` runs wasm-opt concurrently
(takes 132s total). 24 of 25 Chrome launches in the work item succeed;
the crash is timing-dependent.

### Changes

1. **`eng/pipelines/libraries/helix-queues-setup.yml`**: Fix the Android
queue condition to only add the queue for Android/bionic platforms (not
all internal builds).

2. **`src/mono/wasm/Wasm.Build.Tests/BrowserRunner.cs`**:
- Add `CheckBrowserDependencies()` — uses `ldd` on Linux to detect
missing Chrome shared libraries before launch, providing a clear error
message instead of cryptic `TargetClosedException`
- Add `PlaywrightException` to `SpawnBrowserAsync` retry (previously
only `TimeoutException`)
- **Add session-level retry in `RunAsync`** — wraps the full browser
session (launch + navigate) with retry logic, so when Chrome crashes
during `GotoAsync`, a fresh browser instance is created and navigation
is retried. This is the fix for the public build failures.
- Preserve `lastException` as `InnerException` when launch retry is
exhausted

### Reproduction

- **Internal build failure**: Reproduced 100% on codespace without
Chrome system deps. After installing deps, tests pass 100%.
- **Public build failure**: Observed in build 1332440 — Chrome crash
during GotoAsync with concurrent wasm-opt, no missing library errors.

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: lewing

eng/pipelines/libraries/helix-queues-setup.yml

@@ -85,9 +85,11 @@ jobs:
       - $(helix_macos_x64)
 
     # Android
-    # Always use the Ubuntu-based Android queue for internal validation as there is no internal equivalent of
-    # the Windows.11.Amd64.Android.Open queue.
-    - ${{ if or(eq(variables['System.TeamProject'], 'internal'), in(parameters.platform, 'android_x86', 'android_x64', 'linux_bionic_x64')) }}:
+    # Use the Ubuntu-based Android queue for x86/x64/bionic_x64 on all projects,
+    # and also for arm/arm64/bionic_arm/bionic_arm64 on non-public projects (no internal Windows Android queue).
+    - ${{ if in(parameters.platform, 'android_x86', 'android_x64', 'linux_bionic_x64') }}:
+      - Ubuntu.2204.Amd64.Android.29.Open
+    - ${{ if and(ne(variables['System.TeamProject'], 'public'), in(parameters.platform, 'android_arm', 'android_arm64', 'linux_bionic_arm', 'linux_bionic_arm64')) }}:
       - Ubuntu.2204.Amd64.Android.29.Open
     - ${{ if and(eq(variables['System.TeamProject'], 'public'), in(parameters.platform, 'android_arm', 'android_arm64', 'linux_bionic_arm', 'linux_bionic_arm64')) }}:
       - Windows.11.Amd64.Android.Open

src/mono/wasm/Wasm.Build.Tests/BrowserRunner.cs

@@ -4,10 +4,10 @@
 #nullable enable
 
 using System;
-using System.Linq;
-using System.IO;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.RegularExpressions;
+using System.IO;
 using System.Threading.Tasks;
 using Microsoft.Playwright;
 using Wasm.Tests.Internal;
@@ -124,6 +124,7 @@ public async Task<IBrowser> SpawnBrowserAsync(
             chromeArgs = chromeArgs.Append("--headless").ToArray();
         _testOutput.WriteLine($"Launching chrome ('{s_chromePath.Value}') via playwright with args = {string.Join(',', chromeArgs)}");
 
+        Exception? lastException = null;
         int attempt = 0;
         while (attempt < maxRetries)
         {
@@ -143,12 +144,19 @@ public async Task<IBrowser> SpawnBrowserAsync(
             }
             catch (System.TimeoutException ex)
             {
+                lastException = ex;
                 attempt++;
                 _testOutput.WriteLine($"Attempt {attempt} failed with TimeoutException: {ex.Message}");
             }
+            catch (PlaywrightException ex)
+            {
+                lastException = ex;
+                attempt++;
+                _testOutput.WriteLine($"Attempt {attempt} failed with PlaywrightException: {ex.Message}");
+            }
         }
         if (attempt == maxRetries)
-            throw new Exception($"Failed to launch browser after {maxRetries} attempts");
+            throw new InvalidOperationException($"Failed to launch browser after {maxRetries} attempts", lastException);
         return Browser!;
     }
 
@@ -164,9 +172,43 @@ public async Task<IPage> RunAsync(
         Func<string, string>? modifyBrowserUrl = null)
     {
         var urlString = await StartServerAndGetUrlAsync(cmd, args, onServerMessage);
-        var browser = await SpawnBrowserAsync(urlString, headless, locale: locale);
-        var context = await browser.NewContextAsync(new BrowserNewContextOptions { Locale = locale });
-        return await RunAsync(context, urlString, headless, onConsoleMessage, onError, modifyBrowserUrl);
+
+        // Retry the full browser session (launch + navigate) to handle
+        // intermittent Chrome crashes in Docker containers under memory pressure.
+        // Chrome can silently die (OOM killed) during navigation when concurrent
+        // test classes run wasm-opt builds alongside browser tests.
+        const int maxSessionRetries = 2;
+        for (int attempt = 0; ; attempt++)
+        {
+            try
+            {
+                // On retries, only try launching once since SpawnBrowserAsync has its own retry loop
+                int launchRetries = attempt == 0 ? 3 : 1;
+                var browser = await SpawnBrowserAsync(urlString, headless, maxRetries: launchRetries, locale: locale);
+                var context = await browser.NewContextAsync(new BrowserNewContextOptions { Locale = locale });
+                return await RunAsync(context, urlString, headless, onConsoleMessage, onError, modifyBrowserUrl);
+            }
+            catch (Exception ex) when (attempt + 1 < maxSessionRetries &&
+                ex is PlaywrightException)
+            {
+                _testOutput.WriteLine($"Browser session attempt {attempt + 1} failed with {ex.GetType().Name}: {ex.Message}");
+                _testOutput.WriteLine("Retrying with a fresh browser instance...");
+                try
+                {
+                    if (Browser is not null)
+                    {
+                        await Browser.DisposeAsync();
+                        Browser = null;
+                    }
+                    Playwright?.Dispose();
+                    Playwright = null;
+                }
+                catch (Exception disposeEx)
+                {
+                    _testOutput.WriteLine($"Browser cleanup failed: {disposeEx.Message}");
+                }
+            }
+        }
     }
 
     public async Task<IPage> RunAsync(