Reland "Support i18n serif font on Android"

This reverts commit 3228cc2.

Reason for revert:
* Confirmed 94.0.4581.0 does not have the issue.
* See crbug.com/1252383#c17 for the new culprit.

Original change's description:
> Revert "Support i18n `serif` font on Android"
>
> This reverts commit 65ac769.
>
> Reason for revert: crbug.com/1252383
>
> Original change's description:
> > Support i18n `serif` font on Android
> >
> > Android's `fonts.xml` system used to support only one typeface
> > for i18n. We started lifting this limitation in 2016. Android
> > then supported locale-specific `serif` font in P, and Skia
> > supported this in 2018[2].
> >
> > This patch enables Blink to support the i18n `serif` fonts
> > during cascading generic families; e.g.:
> > ```
> >   <div lang="ja" style="font-family: serif">
> > ```
> > should use the `serif` typeface for Japanese.
> >
> > Computing the actual font family in |FontSelector::
> > FamilyNameFromSettings| is not as cheap as other platforms,
> > as it involves actual font look ups and instantiations. This
> > patch changes it to no-op for Android, but instead, uses
> > locale-specific family support in |FontCache|.
> >
> > Note, the system fallback goes different code path; e.g.:
> > ```
> >   <div lang="en" style="font-family: serif">
> > ```
> > uses English `serif` typeface. When it has Japanese text, it
> > is the system fallback who finds the fonts. Supporting the
> > system fallback will be in a separate patch.
> >
> > Design doc (Google only):
> > https://docs.google.com/document/d/16k21QBf-FVsB-3yTHf2bmp5vI56uf44G-Xj_CWfT9Xs/edit?usp=sharing
> >
> > [1] https://skia-review.googlesource.com/c/skia/+/171644
> >
> > Bug: 822142, 1206946
> > Change-Id: I3fe7e53868968342b70caffbb17092630a51e42e
> > Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3003361
> > Reviewed-by: Kent Tamura <[email protected]>
> > Commit-Queue: Koji Ishii <[email protected]>
> > Cr-Commit-Position: refs/heads/master@{#902901}
>
> Bug: 1252383, 822142, 1206946
> Change-Id: Ieceb4b3ec5e07f0ab14df4f29e6fe6589da23d5c
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3191131
> Commit-Queue: Koji Ishii <[email protected]>
> Reviewed-by: Ian Kilpatrick <[email protected]>
> Cr-Commit-Position: refs/heads/main@{#925993}

Bug: 1252383, 822142, 1206946
Change-Id: I2f1fadb51649624641e7acbfa22d54fb26928d93
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3195433
Bot-Commit: Rubber Stamper <[email protected]>
Commit-Queue: Koji Ishii <[email protected]>
Reviewed-by: Yoshifumi Inoue <[email protected]>
Cr-Commit-Position: refs/heads/main@{#927560}

Author: kojiishi

third_party/blink/renderer/platform/fonts/android/font_cache_android.cc

@@ -82,6 +82,41 @@ const AtomicString& FontCache::SystemFontFamily() {
 // static
 void FontCache::SetSystemFontFamily(const AtomicString&) {}
 
+sk_sp<SkTypeface> FontCache::CreateLocaleSpecificTypeface(
+    const FontDescription& font_description,
+    const char* locale_family_name) {
+  const char* bcp47 = font_description.LocaleOrDefault().LocaleForSkFontMgr();
+  DCHECK(bcp47);
+  SkFontMgr* font_manager =
+      font_manager_ ? font_manager_.get() : SkFontMgr::RefDefault().get();
+  sk_sp<SkTypeface> typeface(font_manager->matchFamilyStyleCharacter(
+      locale_family_name, font_description.SkiaFontStyle(), &bcp47,
+      /* bcp47Count */ 1,
+      // |matchFamilyStyleCharacter| is the only API that accepts |bcp47|, but
+      // it also checks if a character has a glyph. To look up the first
+      // match, use the space character, because all fonts are likely to have
+      // a glyph for it.
+      kSpaceCharacter));
+  if (!typeface)
+    return nullptr;
+
+  // When the specified family of the specified language does not exist, we want
+  // to fall back to the specified family of the default language, but
+  // |matchFamilyStyleCharacter| falls back to the default family of the
+  // specified language. Get the default family of the language and compare
+  // with what we get.
+  SkString skia_family_name;
+  typeface->getFamilyName(&skia_family_name);
+  sk_sp<SkTypeface> fallback(font_manager->matchFamilyStyleCharacter(
+      nullptr, font_description.SkiaFontStyle(), &bcp47,
+      /* bcp47Count */ 1, kSpaceCharacter));
+  SkString skia_fallback_name;
+  fallback->getFamilyName(&skia_fallback_name);
+  if (typeface != fallback)
+    return typeface;
+  return nullptr;
+}
+
 scoped_refptr<SimpleFontData> FontCache::PlatformFallbackFontForCharacter(
     const FontDescription& font_description,
     UChar32 c,
@@ -160,6 +195,11 @@ scoped_refptr<SimpleFontData> FontCache::PlatformFallbackFontForCharacter(
 AtomicString FontCache::GetGenericFamilyNameForScript(
     const AtomicString& family_name,
     const FontDescription& font_description) {
+  // If this is a locale-specifc family name, |FontCache| can handle different
+  // typefaces per locale. Let it handle.
+  if (GetLocaleSpecificFamilyName(family_name))
+    return family_name;
+
   // If monospace, do not apply CJK hack to find i18n fonts, because
   // i18n fonts are likely not monospace. Monospace is mostly used
   // for code, but when i18n characters appear in monospace, system

third_party/blink/renderer/platform/fonts/android/font_cache_android_test.cc

@@ -11,6 +11,17 @@
 namespace blink {
 
 class FontCacheAndroidTest : public testing::Test {
+ protected:
+  // Returns a locale-specific `serif` typeface, or `nullptr` if the system
+  // does not have a locale-specific `serif`.
+  sk_sp<SkTypeface> CreateSerifTypeface(const LayoutLocale* locale) {
+    FontCache* font_cache = FontCache::GetFontCache();
+    FontDescription font_description;
+    font_description.SetLocale(locale);
+    font_description.SetGenericFamily(FontDescription::kSerifFamily);
+    return font_cache->CreateLocaleSpecificTypeface(font_description, "serif");
+  }
+
   FontCachePurgePreventer purge_preventer;
 };
 
@@ -31,6 +42,46 @@ TEST_F(FontCacheAndroidTest, FallbackFontForCharacter) {
   EXPECT_TRUE(font_data);
 }
 
+TEST_F(FontCacheAndroidTest, FallbackFontForCharacterSerif) {
+  // Test is valid only if the system has a locale-specific `serif`.
+  const LayoutLocale* ja = LayoutLocale::Get("ja");
+  sk_sp<SkTypeface> serif_ja_typeface = CreateSerifTypeface(ja);
+  if (!serif_ja_typeface)
+    return;
+
+  // When |GenericFamily| set to |kSerifFamily|, it should find the
+  // locale-specific serif font.
+  FontDescription font_description;
+  font_description.SetGenericFamily(FontDescription::kSerifFamily);
+  font_description.SetLocale(ja);
+  FontCache* font_cache = FontCache::GetFontCache();
+  ASSERT_TRUE(font_cache);
+  const UChar32 kTestChar = 0x4E00;  // U+4E00 CJK UNIFIED IDEOGRAPH-4E00
+  scoped_refptr<SimpleFontData> font_data =
+      font_cache->FallbackFontForCharacter(font_description, kTestChar,
+                                           nullptr);
+  EXPECT_TRUE(font_data);
+  EXPECT_EQ(serif_ja_typeface.get(), font_data->PlatformData().Typeface());
+}
+
+TEST_F(FontCacheAndroidTest, LocaleSpecificTypeface) {
+  // Test is valid only if the system has a locale-specific `serif`.
+  const LayoutLocale* ja = LayoutLocale::Get("ja");
+  sk_sp<SkTypeface> serif_ja_typeface = CreateSerifTypeface(ja);
+  if (!serif_ja_typeface)
+    return;
+
+  // If the system has one, it must be different from the default font.
+  FontDescription standard_ja_description;
+  standard_ja_description.SetLocale(ja);
+  standard_ja_description.SetGenericFamily(FontDescription::kStandardFamily);
+  std::string name;
+  FontCache* font_cache = FontCache::GetFontCache();
+  sk_sp<SkTypeface> standard_ja_typeface = font_cache->CreateTypeface(
+      standard_ja_description, FontFaceCreationParams(), name);
+  EXPECT_NE(serif_ja_typeface.get(), standard_ja_typeface.get());
+}
+
 TEST(FontCacheAndroid, GenericFamilyNameForScript) {
   FontDescription english;
   english.SetLocale(LayoutLocale::Get("en"));

third_party/blink/renderer/platform/fonts/font_cache.h

@@ -251,6 +251,13 @@ class PLATFORM_EXPORT FontCache {
   static AtomicString GetGenericFamilyNameForScript(
       const AtomicString& family_name,
       const FontDescription&);
+  // Locale-specific families can use different |SkTypeface| for a family name
+  // if locale is different.
+  static const char* GetLocaleSpecificFamilyName(
+      const AtomicString& family_name);
+  sk_sp<SkTypeface> CreateLocaleSpecificTypeface(
+      const FontDescription& font_description,
+      const char* locale_family_name);
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_LINUX) || defined(OS_CHROMEOS)
@@ -406,6 +413,7 @@ class PLATFORM_EXPORT FontCache {
 
   friend class SimpleFontData;  // For fontDataFromFontPlatformData
   friend class FontFallbackList;
+  FRIEND_TEST_ALL_PREFIXES(FontCacheAndroidTest, LocaleSpecificTypeface);
 };
 
 class PLATFORM_EXPORT FontCachePurgePreventer {
@@ -420,6 +428,18 @@ class PLATFORM_EXPORT FontCachePurgePreventer {
 
 AtomicString ToAtomicString(const SkString&);
 
+#if defined(OS_ANDROID)
+// TODO(crbug.com/1241875) Can this be simplified?
+// static
+inline const char* FontCache::GetLocaleSpecificFamilyName(
+    const AtomicString& family_name) {
+  // Only `serif` has `fallbackFor` according to the current `fonts.xml`.
+  if (family_name == font_family_names::kSerif)
+    return "serif";
+  return nullptr;
+}
+#endif
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_FONTS_FONT_CACHE_H_

third_party/blink/renderer/platform/fonts/font_description.cc

@@ -38,7 +38,7 @@
 #include "third_party/blink/renderer/platform/wtf/text/string_hash.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_hasher.h"
 
-#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+#if defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_ANDROID)
 #include "third_party/blink/renderer/platform/fonts/font_cache.h"
 #endif
 
@@ -268,6 +268,12 @@ FontCacheKey FontDescription::CacheKey(
                          options | font_selection_request_.GetHash() << 9,
                          device_scale_factor_for_key, variation_settings_,
                          is_unique_match);
+#if defined(OS_ANDROID)
+  if (const LayoutLocale* locale = Locale()) {
+    if (FontCache::GetLocaleSpecificFamilyName(creation_params.Family()))
+      cache_key.SetLocale(locale->LocaleForSkFontMgr());
+  }
+#endif  // defined(OS_ANDROID)
   return cache_key;
 }
 

third_party/blink/renderer/platform/fonts/skia/font_cache_skia.cc

@@ -217,6 +217,16 @@ sk_sp<SkTypeface> FontCache::CreateTypeface(
          font_description.GenericFamily() == FontDescription::kStandardFamily);
   name = family.Utf8();
 
+#if defined(OS_ANDROID)
+  // If this is a locale-specific family, try looking up locale-specific
+  // typeface first.
+  if (const char* locale_family = GetLocaleSpecificFamilyName(family)) {
+    if (sk_sp<SkTypeface> typeface =
+            CreateLocaleSpecificTypeface(font_description, locale_family))
+      return typeface;
+  }
+#endif  // defined(OS_ANDROID)
+
 #if defined(OS_WIN)
   // TODO(vmpstr): Deal with paint typeface here.
   if (sideloaded_fonts_) {