Cache synthetic/nearest glyph typefaces under the requested family name (#21993)

* Cache synthetic/nearest glyph typefaces under the requested family name

FontCollectionBase.TryGetGlyphTypeface only cached the resolved typeface under the
requested family name when synthesis FAILED. When TryCreateSyntheticGlyphTypeface
succeeds it registers the synthetic only under the source font's own family names,
never under the name the caller asked for.

A request arriving through a different name therefore never hits the cache and
re-enters synthesis on every call. Synthesis goes through IPlatformTypeface.TryGetStream,
which reads the entire font file into memory and hands it to SKTypeface.FromStream,
which copies it again natively - so every resolution costs one retained copy of the
whole font file.

Two common shapes reach this path:
  - a platform alias, i.e. a family the font manager resolves but that is absent from
    GetInstalledFontFamilyNames(). Android declares several in /system/etc/fonts.xml
    (arial, helvetica, tahoma, verdana, times, courier);
  - a "Family Style" composite decomposed by Typeface.Normalize (e.g. "Arial Black"
    -> family arial + FontWeight.Black), which makes the requested key differ from the
    key the platform returns.

Windows/DirectWrite is structurally immune: every resolvable family is also an installed
family there, so the case-insensitive family-name search finds the synthetic (registered
under its real name) on the second call and the missing entry repairs itself after one
copy. With a platform alias nothing repairs it.

Measured on Android 13 / arm64: a text widget set to "Arial Black" grew the native heap
by +1187 MB over ~14 redraws (chunks of Roboto-Regular.ttf, identified by byte
comparison), until the platform memory guard killed the process at 2.6 GB.

Adds a regression test with an IFontManagerImpl that models a platform alias: without
the fix the second resolution returns a different instance (re-synthesis), with it the
cached one.

* Make the regression test platform-independent

Back the alias with an embedded test font instead of an installed Arial, and
turn the test into a plain [Fact] so it runs on every platform.

The defect being covered lives in FontCollectionBase and is platform-agnostic,
so gating the test behind [Win32Fact] left it unexercised on the Linux and macOS
legs of CI. Relying on an installed system font also made the test dependent on
the build environment.

The fake font manager now always resolves the alias to the regular face of an
embedded font, whatever weight is asked for - which is what a platform alias
actually does - so no system font is involved at all.

* Make the regression test fail against unfixed code

Name the backing font explicitly instead of taking whichever asset
GetAssets enumerates first (currently AdobeBlank2VF.ttf, a blank
variable font), matching the style used elsewhere for embedded test
fonts.

Assert that the first resolution really is a synthesised bold. Without
it, a backing font that cannot be emboldened makes TryCreateSyntheticGlyphTypeface
fail, the old else branch caches the nearest match, and the whole test
passes against unfixed code.

Verified both ways: FontCollectionTests is 4/4 with the fix, and
Should_Cache_Synthetic_Match_Under_Requested_Family_Name is the single
failure without it.

---------

Co-authored-by: ronnycohen <19652995+ronnycohen@users.noreply.github.com>
Co-authored-by: Benedikt Stebner <Gillibald@users.noreply.github.com>

Author: ronnycohen

src/Avalonia.Base/Media/Fonts/FontCollectionBase.cs

@@ -852,11 +852,15 @@ protected bool TryGetGlyphTypeface(
                         {
                             glyphTypeface = syntheticGlyphTypeface;
                         }
-                        else
-                        {
-                            // Cache the nearest match for future lookups
-                            TryAddGlyphTypeface(familyName, key, glyphTypeface);
-                        }
+
+                        // Cache the resolved typeface under the REQUESTED family name, whether it is
+                        // the nearest match or a synthetic one. TryCreateSyntheticGlyphTypeface only
+                        // registers the synthetic under the *source font's own* family names, so a
+                        // request coming through a different name (an alias, or a "Family Style"
+                        // composite normalized by Typeface.Normalize) never hits the cache and
+                        // re-enters synthesis on every single call — and synthesis copies the whole
+                        // font file through TryGetStream.
+                        TryAddGlyphTypeface(familyName, key, glyphTypeface);
                     }
 
                     return true;

tests/Avalonia.Skia.UnitTests/Media/FontCollectionTests.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.IO;
 using Avalonia.Media;
 using Avalonia.Media.Fonts;
 using Avalonia.Platform;
@@ -148,5 +149,125 @@ public override bool TryCreateSyntheticGlyphTypeface(
                 return base.TryCreateSyntheticGlyphTypeface(glyphTypeface, style, weight, stretch, out syntheticGlyphTypeface);
             }
         }
+
+        [Fact]
+        public void Should_Cache_Synthetic_Match_Under_Requested_Family_Name()
+        {
+            var fontManager = new AliasFontManagerImpl(alias: "MyAlias");
+
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface.With(fontManagerImpl: fontManager)))
+            {
+                var fontCollection = new TestSystemFontCollection(fontManager);
+                var blackKey = new FontCollectionKey(FontStyle.Normal, FontWeight.Black, FontStretch.Normal);
+
+                // Prime the cache with the bare family, as any control asking for the alias at a
+                // normal weight would. This is what makes the next lookup take the nearest match.
+                Assert.True(fontCollection.TryGetGlyphTypeface(
+                    "MyAlias", FontStyle.Normal, FontWeight.Normal, FontStretch.Normal, out _));
+
+                Assert.True(fontCollection.TryGetGlyphTypeface(
+                    "MyAlias", FontStyle.Normal, FontWeight.Black, FontStretch.Normal, out var first));
+
+                // Guards the test itself: the first resolution must really be a synthesised bold.
+                // If the backing font could not be emboldened, TryCreateSyntheticGlyphTypeface would
+                // fail and the old else branch would cache the nearest match, making everything below
+                // pass against unfixed code.
+                Assert.Equal(FontSimulations.Bold, first.FontSimulations);
+
+                var creationsAfterFirstCall = fontManager.StreamTypefaceCreations;
+
+                for (var i = 0; i < 10; i++)
+                {
+                    Assert.True(fontCollection.TryGetGlyphTypeface(
+                        "MyAlias", FontStyle.Normal, FontWeight.Black, FontStretch.Normal, out var next));
+
+                    Assert.Same(first, next);
+                }
+
+                // Each synthesis copies the entire font file through IPlatformTypeface.TryGetStream,
+                // so an uncached synthetic means one full font copy per call.
+                Assert.Equal(creationsAfterFirstCall, fontManager.StreamTypefaceCreations);
+
+                Assert.True(fontCollection.GlyphTypefaceCache.TryGetValue("MyAlias", out var cached));
+                Assert.True(cached.ContainsKey(blackKey));
+            }
+        }
+
+        /// <summary>
+        /// Font manager whose <c>MyAlias</c> family resolves through the platform but is absent from
+        /// the installed family list — the shape of a platform alias (for instance Android's
+        /// <c>&lt;alias name="arial" to="sans-serif"/&gt;</c> in <c>/system/etc/fonts.xml</c>).
+        /// Such a family cannot be found again by the family-name search, so nothing repairs a
+        /// missing cache entry.
+        ///
+        /// The alias is backed by an embedded test font rather than an installed one, so the test
+        /// runs identically on every platform.
+        /// </summary>
+        private sealed class AliasFontManagerImpl : IFontManagerImpl
+        {
+            /// <summary>Named explicitly rather than enumerated: the backing font must be a real
+            /// text face, since a font that cannot be emboldened would make the test pass against
+            /// unfixed code (the old else branch cached the nearest match).</summary>
+            private const string BackingFontUri =
+                "resm:Avalonia.Skia.UnitTests.Assets.NotoMono-Regular.ttf?assembly=Avalonia.Skia.UnitTests";
+
+            private readonly IFontManagerImpl _inner = new FontManagerImpl();
+            private readonly string _alias;
+
+            public AliasFontManagerImpl(string alias)
+            {
+                _alias = alias;
+            }
+
+            /// <summary>Number of typefaces created from a stream, i.e. of synthetic emboldenings.</summary>
+            public int StreamTypefaceCreations { get; private set; }
+
+            public string GetDefaultFontFamilyName() => _inner.GetDefaultFontFamilyName();
+
+            public string[] GetInstalledFontFamilyNames(bool checkForUpdates = false)
+                => Array.Empty<string>();
+
+            public bool TryCreateGlyphTypeface(string familyName, FontStyle style, FontWeight weight,
+                FontStretch stretch, [NotNullWhen(true)] out IPlatformTypeface? platformTypeface)
+            {
+                // The alias always resolves to the regular face of the backing font, never to the
+                // requested weight — exactly what a platform alias does.
+                if (string.Equals(familyName, _alias, StringComparison.OrdinalIgnoreCase))
+                {
+                    using var stream = OpenBackingFont();
+
+                    return _inner.TryCreateGlyphTypeface(stream, FontSimulations.None, out platformTypeface);
+                }
+
+                platformTypeface = null;
+
+                return false;
+            }
+
+            private static Stream OpenBackingFont()
+            {
+                var assetLoader = AvaloniaLocator.Current.GetRequiredService<IAssetLoader>();
+
+                return assetLoader.Open(new Uri(BackingFontUri, UriKind.Absolute));
+            }
+
+            public bool TryCreateGlyphTypeface(Stream stream, FontSimulations fontSimulations,
+                [NotNullWhen(true)] out IPlatformTypeface? platformTypeface)
+            {
+                StreamTypefaceCreations++;
+
+                return _inner.TryCreateGlyphTypeface(stream, fontSimulations, out platformTypeface);
+            }
+
+            public bool TryGetFamilyTypefaces(string familyName,
+                [NotNullWhen(true)] out IReadOnlyList<Typeface>? familyTypefaces)
+                => _inner.TryGetFamilyTypefaces(familyName, out familyTypefaces);
+
+            public bool TryMatchCharacter(int codepoint, FontStyle fontStyle, FontWeight fontWeight,
+                FontStretch fontStretch, string? familyName, CultureInfo? culture,
+                [NotNullWhen(true)] out IPlatformTypeface? platformTypeface)
+                => _inner.TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch, familyName,
+                    culture, out platformTypeface);
+        }
     }
 }