Add support for fallbackFor in Android parser.

Change-Id: Id328c67b6ad5d76584030f480316425f25979ebf
Reviewed-on: https://skia-review.googlesource.com/c/171644
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Ben Wagner <bungeman@google.com>

Author: Ben Wagner

resources/fonts/fonts.xml

@@ -24,9 +24,11 @@
     <family name="Em"><font weight="400" style="normal">Em.ttf</font></family>
     <family name="HangingS"><font weight="400" style="normal">HangingS.ttf</font></family>
     <family name="HintGasp"><font weight="400" style="normal">hintgasp.ttf</font></family>
-    <family name="RTeallyBigA"><font weight="400" style="normal">ReallyBigA.ttf</font></family>
+    <family name="ReallyBigA"><font weight="400" style="normal">ReallyBigA.ttf</font></family>
     <family name="Spider"><font weight="400" style="normal">SpiderSymbol.ttf</font></family>
-    <family name="TestTTC0"><font weight="400" style="normal" index="0">test.ttc</font></family>
-    <family name="TestTTC1"><font weight="400" style="normal" index="1">test.ttc</font></family>
+    <family>
+        <font weight="400" style="normal" index="0">test.ttc</font>
+        <font weight="700" style="normal" index="1" fallbackFor="sans-serif">test.ttc</font>
+    </family>
     <family name="Funkster"><font weight="400" style="normal">Funkster.ttf</font></family>
 </familyset>

src/ports/SkFontMgr_android.cpp

@@ -178,6 +178,8 @@ class SkFontStyleSet_Android : public SkFontStyleSet {
         if (family.fNames.count() > 0) {
             cannonicalFamilyName = &family.fNames[0];
         }
+        fFallbackFor = family.fFallbackFor;
+
         // TODO? make this lazy
         for (int i = 0; i < family.fFonts.count(); ++i) {
             const FontFileInfo& fontFile = family.fFonts[i];
@@ -268,6 +270,7 @@ class SkFontStyleSet_Android : public SkFontStyleSet {
 
 private:
     SkTArray<sk_sp<SkTypeface_AndroidSystem>> fStyles;
+    SkString fFallbackFor;
 
     friend struct NameToFamily;
     friend class SkFontMgr_Android;
@@ -370,12 +373,16 @@ class SkFontMgr_Android : public SkFontMgr {
     }
 
     static sk_sp<SkTypeface_AndroidSystem> find_family_style_character(
+            const SkString& familyName,
             const SkTArray<NameToFamily, true>& fallbackNameToFamilyMap,
             const SkFontStyle& style, bool elegant,
             const SkString& langTag, SkUnichar character)
     {
         for (int i = 0; i < fallbackNameToFamilyMap.count(); ++i) {
             SkFontStyleSet_Android* family = fallbackNameToFamilyMap[i].styleSet;
+            if (familyName != family->fFallbackFor) {
+                continue;
+            }
             sk_sp<SkTypeface_AndroidSystem> face(family->matchStyle(style));
 
             if (!langTag.isEmpty() &&
@@ -414,28 +421,31 @@ class SkFontMgr_Android : public SkFontMgr {
         // As a result, it is not possible to know the variant context from the font alone.
         // TODO: add 'is_elegant' and 'is_compact' bits to 'style' request.
 
-        // The first time match anything elegant, second time anything not elegant.
-        for (int elegant = 2; elegant --> 0;) {
-            for (int bcp47Index = bcp47Count; bcp47Index --> 0;) {
-                SkLanguage lang(bcp47[bcp47Index]);
-                while (!lang.getTag().isEmpty()) {
-                    sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
-                        find_family_style_character(fFallbackNameToFamilyMap,
-                                                    style, SkToBool(elegant),
-                                                    lang.getTag(), character);
-                    if (matchingTypeface) {
-                        return matchingTypeface.release();
+        SkString familyNameString(familyName);
+        for (const SkString& currentFamilyName : { familyNameString, SkString() }) {
+            // The first time match anything elegant, second time anything not elegant.
+            for (int elegant = 2; elegant --> 0;) {
+                for (int bcp47Index = bcp47Count; bcp47Index --> 0;) {
+                    SkLanguage lang(bcp47[bcp47Index]);
+                    while (!lang.getTag().isEmpty()) {
+                        sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
+                            find_family_style_character(currentFamilyName, fFallbackNameToFamilyMap,
+                                                        style, SkToBool(elegant),
+                                                        lang.getTag(), character);
+                        if (matchingTypeface) {
+                            return matchingTypeface.release();
+                        }
+
+                        lang = lang.getParent();
                     }
-
-                    lang = lang.getParent();
                 }
-            }
-            sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
-                find_family_style_character(fFallbackNameToFamilyMap,
-                                            style, SkToBool(elegant),
-                                            SkString(), character);
-            if (matchingTypeface) {
-                return matchingTypeface.release();
+                sk_sp<SkTypeface_AndroidSystem> matchingTypeface =
+                    find_family_style_character(currentFamilyName, fFallbackNameToFamilyMap,
+                                                style, SkToBool(elegant),
+                                                SkString(), character);
+                if (matchingTypeface) {
+                    return matchingTypeface.release();
+                }
             }
         }
         return nullptr;
@@ -521,30 +531,37 @@ class SkFontMgr_Android : public SkFontMgr {
     SkTArray<NameToFamily, true> fNameToFamilyMap;
     SkTArray<NameToFamily, true> fFallbackNameToFamilyMap;
 
-    void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const bool isolated) {
-        for (int i = 0; i < families.count(); i++) {
-            FontFamily& family = *families[i];
-
-            SkTArray<NameToFamily, true>* nameToFamily = &fNameToFamilyMap;
-            if (family.fIsFallbackFont) {
-                nameToFamily = &fFallbackNameToFamilyMap;
+    void addFamily(FontFamily& family, const bool isolated, int familyIndex) {
+        SkTArray<NameToFamily, true>* nameToFamily = &fNameToFamilyMap;
+        if (family.fIsFallbackFont) {
+            nameToFamily = &fFallbackNameToFamilyMap;
 
-                if (0 == family.fNames.count()) {
-                    SkString& fallbackName = family.fNames.push_back();
-                    fallbackName.printf("%.2x##fallback", i);
-                }
+            if (0 == family.fNames.count()) {
+                SkString& fallbackName = family.fNames.push_back();
+                fallbackName.printf("%.2x##fallback", familyIndex);
             }
+        }
 
-            sk_sp<SkFontStyleSet_Android> newSet =
-                sk_make_sp<SkFontStyleSet_Android>(family, fScanner, isolated);
-            if (0 == newSet->count()) {
-                continue;
-            }
+        sk_sp<SkFontStyleSet_Android> newSet =
+            sk_make_sp<SkFontStyleSet_Android>(family, fScanner, isolated);
+        if (0 == newSet->count()) {
+            return;
+        }
 
-            for (const SkString& name : family.fNames) {
-                nameToFamily->emplace_back(NameToFamily{name, newSet.get()});
-            }
-            fStyleSets.emplace_back(std::move(newSet));
+        for (const SkString& name : family.fNames) {
+            nameToFamily->emplace_back(NameToFamily{name, newSet.get()});
+        }
+        fStyleSets.emplace_back(std::move(newSet));
+    }
+    void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const bool isolated) {
+        int familyIndex = 0;
+        for (FontFamily* family : families) {
+            addFamily(*family, isolated, familyIndex++);
+            family->fallbackFamilies.foreach([this, isolated, &familyIndex]
+                (SkString, std::unique_ptr<FontFamily>* fallbackFamily) {
+                    addFamily(*(*fallbackFamily).get(), isolated, familyIndex++);
+                }
+            );
         }
     }
 

src/ports/SkFontMgr_android_parser.cpp

@@ -208,6 +208,7 @@ static const TagHandler fontHandler = {
         // The character data should be a filename.
         FontFileInfo& file = self->fCurrentFamily->fFonts.push_back();
         self->fCurrentFontInfo = &file;
+        SkString fallbackFor;
         for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
             const char* name = attributes[i];
             const char* value = attributes[i+1];
@@ -227,8 +228,27 @@ static const TagHandler fontHandler = {
                 if (!parse_non_negative_integer(value, &file.fIndex)) {
                     SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid index", value);
                 }
+            } else if (MEMEQ("fallbackFor", name, nameLen)) {
+                /** fallbackFor specifies a family fallback and should have been on family. */
+                fallbackFor = value;
             }
         }
+        if (!fallbackFor.isEmpty()) {
+            std::unique_ptr<FontFamily>* fallbackFamily =
+                    self->fCurrentFamily->fallbackFamilies.find(fallbackFor);
+            if (!fallbackFamily) {
+                std::unique_ptr<FontFamily> newFallbackFamily(
+                        new FontFamily(self->fCurrentFamily->fBasePath, true));
+                fallbackFamily = self->fCurrentFamily->fallbackFamilies.set(
+                        fallbackFor, std::move(newFallbackFamily));
+                (*fallbackFamily)->fLanguages = self->fCurrentFamily->fLanguages;
+                (*fallbackFamily)->fVariant = self->fCurrentFamily->fVariant;
+                (*fallbackFamily)->fOrder = self->fCurrentFamily->fOrder;
+                (*fallbackFamily)->fFallbackFor = fallbackFor;
+            }
+            self->fCurrentFontInfo = &(*fallbackFamily)->fFonts.emplace_back(file);
+            self->fCurrentFamily->fFonts.pop_back();
+        }
     },
     /*end*/[](FamilyData* self, const char* tag) {
         trim_string(&self->fCurrentFontInfo->fFileName);

src/ports/SkFontMgr_android_parser.h

@@ -12,6 +12,7 @@
 #include "SkString.h"
 #include "SkTArray.h"
 #include "SkTDArray.h"
+#include "SkTHash.h"
 #include "SkTypes.h"
 
 #include <climits>
@@ -94,9 +95,11 @@ struct FontFamily {
     SkTArray<SkString, true> fNames;
     SkTArray<FontFileInfo, true> fFonts;
     SkTArray<SkLanguage, true> fLanguages;
+    SkTHashMap<SkString, std::unique_ptr<FontFamily>> fallbackFamilies;
     FontVariant fVariant;
     int fOrder; // internal to the parser, not useful to users.
     bool fIsFallbackFont;
+    SkString fFallbackFor;
     const SkString fBasePath;
 };
 

tests/FontMgrAndroidParserTest.cpp

@@ -40,8 +40,8 @@ static bool isDIGIT(int c) {
     return ('0' <= c && c <= '9');
 }
 
-void ValidateLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* firstExpectedFile,
-                         skiatest::Reporter* reporter) {
+static void ValidateLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* firstExpectedFile,
+                                skiatest::Reporter* reporter) {
     REPORTER_ASSERT(reporter, fontFamilies[0]->fNames.count() == 5);
     REPORTER_ASSERT(reporter, !strcmp(fontFamilies[0]->fNames[0].c_str(), "sans-serif"));
     REPORTER_ASSERT(reporter,
@@ -73,7 +73,23 @@ void ValidateLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* firstE
     }
 }
 
-void DumpLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* label) {
+static void DumpFiles(const FontFamily& fontFamily) {
+    for (int j = 0; j < fontFamily.fFonts.count(); ++j) {
+        const FontFileInfo& ffi = fontFamily.fFonts[j];
+        SkDebugf("  file (%d) %s#%d", ffi.fWeight, ffi.fFileName.c_str(), ffi.fIndex);
+        for (const auto& coordinate : ffi.fVariationDesignPosition) {
+            SkDebugf(" @'%c%c%c%c'=%f",
+                        (coordinate.axis >> 24) & 0xFF,
+                        (coordinate.axis >> 16) & 0xFF,
+                        (coordinate.axis >>  8) & 0xFF,
+                        (coordinate.axis      ) & 0xFF,
+                        coordinate.value);
+        }
+        SkDebugf("\n");
+    }
+}
+
+static void DumpLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* label) {
     if (!FLAGS_verboseFontMgr) {
         return;
     }
@@ -97,19 +113,13 @@ void DumpLoadedFonts(SkTDArray<FontFamily*> fontFamilies, const char* label) {
         for (int j = 0; j < fontFamilies[i]->fNames.count(); ++j) {
             SkDebugf("  name %s\n", fontFamilies[i]->fNames[j].c_str());
         }
-        for (int j = 0; j < fontFamilies[i]->fFonts.count(); ++j) {
-            const FontFileInfo& ffi = fontFamilies[i]->fFonts[j];
-            SkDebugf("  file (%d) %s#%d", ffi.fWeight, ffi.fFileName.c_str(), ffi.fIndex);
-            for (const auto& coordinate : ffi.fVariationDesignPosition) {
-                SkDebugf(" @'%c%c%c%c'=%f",
-                         (coordinate.axis >> 24) & 0xFF,
-                         (coordinate.axis >> 16) & 0xFF,
-                         (coordinate.axis >>  8) & 0xFF,
-                         (coordinate.axis      ) & 0xFF,
-                         coordinate.value);
+        DumpFiles(*fontFamilies[i]);
+        fontFamilies[i]->fallbackFamilies.foreach(
+            [](SkString, std::unique_ptr<FontFamily>* fallbackFamily) {
+                SkDebugf("  Fallback for: %s\n", (*fallbackFamily)->fFallbackFor.c_str());
+                DumpFiles(*(*fallbackFamily).get());
             }
-            SkDebugf("\n");
-        }
+        );
     }
     SkDebugf("\n\n");
 }
@@ -340,4 +350,29 @@ DEF_TEST(FontMgrAndroidSystemVariableTypeface, reporter) {
     }
 }
 
+DEF_TEST(FontMgrAndroidSystemFallbackFor, reporter) {
+    constexpr char fontsXmlFilename[] = "fonts/fonts.xml";
+    SkString basePath = GetResourcePath("fonts/");
+    SkString fontsXml = GetResourcePath(fontsXmlFilename);
+
+    if (!sk_exists(fontsXml.c_str())) {
+        ERRORF(reporter, "file missing: %s\n", fontsXmlFilename);
+        return;
+    }
+
+    SkFontMgr_Android_CustomFonts custom;
+    custom.fSystemFontUse = SkFontMgr_Android_CustomFonts::kOnlyCustom;
+    custom.fBasePath = basePath.c_str();
+    custom.fFontsXml = fontsXml.c_str();
+    custom.fFallbackFontsXml = nullptr;
+    custom.fIsolated = false;
+
+    sk_sp<SkFontMgr> fontMgr(SkFontMgr_New_Android(&custom));
+    // "sans-serif" in "fonts/fonts.xml" is "fonts/Distortable.ttf", which doesn't have a '!'
+    // but "TestTTC" has a bold font which does have '!' and is marked as fallback for "sans-serif"
+    // and should take precedence over the same font marked as normal weight next to it.
+    sk_sp<SkTypeface> typeface(fontMgr->matchFamilyStyleCharacter(
+        "sans-serif", SkFontStyle(), nullptr, 0, '!'));
 
+    REPORTER_ASSERT(reporter, typeface->fontStyle() == SkFontStyle::Bold());
+}