Fix Markdown preview crash on UTF-8 files with >2MB size and <1.5M characters (#47391)

`NavigateToString` throws `ArgumentException` when previewing Markdown
files containing many multi-byte UTF-8 characters (e.g., CJK) — file
size exceeds 2MB but character count stays under 1.5M, bypassing the
guard.

## Summary of the Pull Request

The size guard in `MarkdownPreviewHandlerControl` used
`markdownHTML.Length` (character count / UTF-16 code units), but
WebView2's `NavigateToString` limit is measured in **bytes**. A string
with 700K CJK characters has only 700K `.Length` units but ~2.1MB of
UTF-8 bytes — enough to crash the API while passing the old check.

**Changes:**
- **`MarkdownPreviewHandlerControl.cs`**: Replace character-count guard
with UTF-8 byte count:
  ```csharp
  // Before
  if (markdownHTML.Length > 1_500_000)

  // After
  if (System.Text.Encoding.UTF8.GetByteCount(markdownHTML) > 1_500_000)
  ```
When the byte threshold is exceeded, content is written to a temp file
and loaded via `_browser.Source` instead of `NavigateToString` —
existing fallback path, now correctly triggered.

- **`MarkdownPreviewHandlerTest.cs`**: Added 3 regression tests to
prevent this class of bug from recurring:
1. Multi-byte UTF-8 content (CJK, <1.5M chars but >2MB bytes) →
temp-file navigation path
2. Small ASCII content within both thresholds → `NavigateToString` path
3. Large ASCII content exceeding 1.5M chars → temp-file navigation path

## PR Checklist

- [ ] **Communication:** I've discussed this with core contributors
already. If the work hasn't been agreed, this work might be rejected
- [x] **Tests:** Added/updated and all pass
- [ ] **Localization:** All end-user-facing strings can be localized
- [ ] **Dev docs:** Added/updated
- [ ] **New binaries:** Added on the required places
- [ ] [JSON for
signing](https://github.com/microsoft/PowerToys/blob/main/.pipelines/ESRPSigning_core.json)
for new binaries
- [ ] [WXS for
installer](https://github.com/microsoft/PowerToys/blob/main/installer/PowerToysSetup/Product.wxs)
for new binaries and localization folder
- [ ] [YML for CI
pipeline](https://github.com/microsoft/PowerToys/blob/main/.pipelines/ci/templates/build-powertoys-steps.yml)
for new test projects
- [ ] [YML for signed
pipeline](https://github.com/microsoft/PowerToys/blob/main/.pipelines/release.yml)
- [ ] **Documentation updated:** If checked, please file a pull request
on [our docs
repo](https://github.com/MicrosoftDocs/windows-uwp/tree/docs/hub/powertoys)
and link it here: #xxx

## Detailed Description of the Pull Request / Additional comments

The existing fallback (write HTML to a temp file, navigate via
`_browser.Source`) was already correct and handles arbitrarily large
content safely. The only bug was in the guard condition that decides
when to use it — it measured the wrong unit (characters vs. bytes).
Single-byte ASCII content is unaffected; only multi-byte Unicode content
was under-counted.

The tests use reflection to read the private `_localFileURI` field.
Since this field is set synchronously before `Controls.Add(_browser)`,
the check is race-free: once the wait loop exits with `Controls.Count >
0`, `_localFileURI` is guaranteed to have its final value.

## Validation Steps Performed

- Verified the fix by reasoning through the byte math: a file with 700K
CJK characters → `Length` = 700K (passes old check) → UTF-8 bytes ≈
2.1MB (fails new check → uses temp file path, no crash).
- Added 3 targeted unit tests in `UnitTests-MarkdownPreviewHandler`
covering the multi-byte threshold boundary; all 14 tests in the suite
pass (14/14).

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: MuyuanMS <116717757+MuyuanMS@users.noreply.github.com>
Co-authored-by: Muyuan Li (from Dev Box) <muyuanli@microsoft.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

src/modules/previewpane/MarkdownPreviewHandler/MarkdownPreviewHandlerControl.cs

@@ -182,8 +182,9 @@ public override void DoPreview<T>(T dataSource)
 
                         // WebView2.NavigateToString() limitation
                         // See https://learn.microsoft.com/dotnet/api/microsoft.web.webview2.core.corewebview2.navigatetostring?view=webview2-dotnet-1.0.864.35#remarks
-                        // While testing the limit, it turned out it is ~1.5MB, so to be on a safe side we go for 1.5m bytes
-                        if (markdownHTML.Length > 1_500_000)
+                        // While testing the limit, it turned out it is ~1.5MB of UTF-8 encoded content, so to be on the safe side we check the UTF-8 byte count.
+                        // Using character count (string.Length) is not sufficient because multi-byte UTF-8 characters (e.g. CJK) can cause the byte size to exceed the limit even when the character count is below it.
+                        if (System.Text.Encoding.UTF8.GetByteCount(markdownHTML) > 1_500_000)
                         {
                             string filename = _webView2UserDataFolder + "\\" + Guid.NewGuid().ToString() + ".html";
                             File.WriteAllText(filename, markdownHTML);

src/modules/previewpane/UnitTests-MarkdownPreviewHandler/MarkdownPreviewHandlerTest.cs

@@ -4,6 +4,9 @@
 
 using System;
 using System.Drawing;
+using System.IO;
+using System.Reflection;
+using System.Text;
 using System.Threading;
 using System.Windows.Forms;
 
@@ -16,6 +19,9 @@ namespace MarkdownPreviewHandlerUnitTests
     [STATestClass]
     public class MarkdownPreviewHandlerTest
     {
+        private const int NavigateToStringUtf8LimitInBytes = 1_500_000;
+        private const int OversizedUtf8FileThresholdInBytes = 2_000_000;
+
         // A long timeout is needed. WebView2 can take a long time to load the first time in some CI systems.
         private static readonly int HardTimeoutInMilliseconds = 60000;
         private static readonly int SleepTimeInMilliseconds = 200;
@@ -161,5 +167,141 @@ public void MarkdownPreviewHandlerControlUpdateInfobarSettingsWhenDoPreviewIsCal
                 Assert.AreEqual(true, ((RichTextBox)markdownPreviewHandlerControl.Controls[1]).Multiline);
             }
         }
+
+        [TestMethod]
+        public void MarkdownPreviewHandlerControlUsesTempFileNavigationWhenUtf8ByteCountExceedsThresholdWithMultiByteCharacters()
+        {
+            string content = new string('漢', 700_000);
+
+            Assert.IsTrue(content.Length < NavigateToStringUtf8LimitInBytes);
+            Assert.IsTrue(Encoding.UTF8.GetByteCount(content) > OversizedUtf8FileThresholdInBytes);
+
+            string filePath = CreateMarkdownFile(content);
+
+            try
+            {
+                using (var markdownPreviewHandlerControl = new MarkdownPreviewHandlerControl())
+                {
+                    markdownPreviewHandlerControl.DoPreview(filePath);
+
+                    WaitForBrowserControl(markdownPreviewHandlerControl);
+
+                    AssertUsesTempFileNavigation(markdownPreviewHandlerControl);
+                }
+            }
+            finally
+            {
+                DeleteFileIfExists(filePath);
+            }
+        }
+
+        [TestMethod]
+        public void MarkdownPreviewHandlerControlUsesNavigateToStringWhenContentIsWithinCharacterAndUtf8ByteThresholds()
+        {
+            string content = new string('a', 10_000);
+
+            Assert.IsTrue(content.Length < NavigateToStringUtf8LimitInBytes);
+            Assert.IsTrue(Encoding.UTF8.GetByteCount(content) < NavigateToStringUtf8LimitInBytes);
+
+            string filePath = CreateMarkdownFile(content);
+
+            try
+            {
+                using (var markdownPreviewHandlerControl = new MarkdownPreviewHandlerControl())
+                {
+                    markdownPreviewHandlerControl.DoPreview(filePath);
+
+                    WaitForBrowserControl(markdownPreviewHandlerControl);
+
+                    AssertUsesNavigateToString(markdownPreviewHandlerControl);
+                }
+            }
+            finally
+            {
+                DeleteFileIfExists(filePath);
+            }
+        }
+
+        [TestMethod]
+        public void MarkdownPreviewHandlerControlUsesTempFileNavigationWhenAsciiContentExceedsCharacterThreshold()
+        {
+            string content = new string('a', 1_600_000);
+
+            Assert.IsTrue(content.Length > NavigateToStringUtf8LimitInBytes);
+            Assert.IsTrue(Encoding.UTF8.GetByteCount(content) > NavigateToStringUtf8LimitInBytes);
+
+            string filePath = CreateMarkdownFile(content);
+
+            try
+            {
+                using (var markdownPreviewHandlerControl = new MarkdownPreviewHandlerControl())
+                {
+                    markdownPreviewHandlerControl.DoPreview(filePath);
+
+                    WaitForBrowserControl(markdownPreviewHandlerControl);
+
+                    AssertUsesTempFileNavigation(markdownPreviewHandlerControl);
+                }
+            }
+            finally
+            {
+                DeleteFileIfExists(filePath);
+            }
+        }
+
+        private static void WaitForBrowserControl(MarkdownPreviewHandlerControl markdownPreviewHandlerControl)
+        {
+            int beforeTick = Environment.TickCount;
+
+            while (markdownPreviewHandlerControl.Controls.Count == 0 && Environment.TickCount < beforeTick + HardTimeoutInMilliseconds)
+            {
+                Application.DoEvents();
+                Thread.Sleep(SleepTimeInMilliseconds);
+            }
+
+            Assert.AreEqual(1, markdownPreviewHandlerControl.Controls.Count);
+            Assert.IsInstanceOfType(markdownPreviewHandlerControl.Controls[0], typeof(WebView2));
+        }
+
+        private static void AssertUsesTempFileNavigation(MarkdownPreviewHandlerControl markdownPreviewHandlerControl)
+        {
+            Uri localFileUri = GetLocalFileUri(markdownPreviewHandlerControl);
+
+            Assert.IsNotNull(localFileUri);
+            Assert.IsTrue(File.Exists(localFileUri.LocalPath));
+            Assert.AreEqual(localFileUri, ((WebView2)markdownPreviewHandlerControl.Controls[0]).Source);
+        }
+
+        private static void AssertUsesNavigateToString(MarkdownPreviewHandlerControl markdownPreviewHandlerControl)
+        {
+            Assert.IsNull(GetLocalFileUri(markdownPreviewHandlerControl));
+        }
+
+        private static Uri GetLocalFileUri(MarkdownPreviewHandlerControl markdownPreviewHandlerControl)
+        {
+            FieldInfo localFileUriField = typeof(MarkdownPreviewHandlerControl).GetField("_localFileURI", BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.IsNotNull(localFileUriField);
+
+            return (Uri)localFileUriField.GetValue(markdownPreviewHandlerControl);
+        }
+
+        private static string CreateMarkdownFile(string content)
+        {
+            string generatedFilesDirectory = Path.Combine(AppContext.BaseDirectory, "HelperFiles", "Generated");
+            Directory.CreateDirectory(generatedFilesDirectory);
+
+            string filePath = Path.Combine(generatedFilesDirectory, $"{Guid.NewGuid():N}.md");
+            File.WriteAllText(filePath, content, Encoding.UTF8);
+            return filePath;
+        }
+
+        private static void DeleteFileIfExists(string filePath)
+        {
+            if (File.Exists(filePath))
+            {
+                File.Delete(filePath);
+            }
+        }
     }
 }