Add font fallback support to SkFontMgr_fontconfig.

src/ports/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDataTable.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
@@ skipping 78 matching lines @@
         if (FcGetVersion() < 21091) {
             gFCMutex.assertHeld();
         } else {
             SkASSERT(true == *THREAD_FC_LOCKED);
         }
     ) }
 };
 
 } // namespace
 
-template<typename T, void (*P)(T*)> void FcTDestroy(T* t) {
+template<typename T, void (*D)(T*)> void FcTDestroy(T* t) {
     FCLocker::AssertHeld();
-    P(t);
+    D(t);
 }
-template <typename T, void (*P)(T*)> class SkAutoFc
-    : public SkAutoTCallVProc<T, FcTDestroy<T, P> > {
+template <typename T, T* (*C)(), void (*D)(T*)> class SkAutoFc
+    : public SkAutoTCallVProc<T, FcTDestroy<T, D> > {
 public:
-    SkAutoFc(T* obj) : SkAutoTCallVProc<T, FcTDestroy<T, P> >(obj) {}
+    SkAutoFc() : SkAutoTCallVProc<T, FcTDestroy<T, D> >(C()) {
+        T* obj = this->operator T*();
+        SK_ALWAYSBREAK(NULL != obj);
+    }
+    explicit SkAutoFc(T* obj) : SkAutoTCallVProc<T, FcTDestroy<T, D> >(obj) {}
 };
 
-typedef SkAutoFc<FcConfig, FcConfigDestroy> SkAutoFcConfig;
-typedef SkAutoFc<FcFontSet, FcFontSetDestroy> SkAutoFcFontSet;
-typedef SkAutoFc<FcLangSet, FcLangSetDestroy> SkAutoFcLangSet;
-typedef SkAutoFc<FcObjectSet, FcObjectSetDestroy> SkAutoFcObjectSet;
-typedef SkAutoFc<FcPattern, FcPatternDestroy> SkAutoFcPattern;
+typedef SkAutoFc<FcCharSet, FcCharSetCreate, FcCharSetDestroy> SkAutoFcCharSet;
+typedef SkAutoFc<FcConfig, FcConfigCreate, FcConfigDestroy> SkAutoFcConfig;
+typedef SkAutoFc<FcFontSet, FcFontSetCreate, FcFontSetDestroy> SkAutoFcFontSet;
+typedef SkAutoFc<FcLangSet, FcLangSetCreate, FcLangSetDestroy> SkAutoFcLangSet;
+typedef SkAutoFc<FcObjectSet, FcObjectSetCreate, FcObjectSetDestroy> SkAutoFcObjectSet;
+typedef SkAutoFc<FcPattern, FcPatternCreate, FcPatternDestroy> SkAutoFcPattern;
 
 static int get_int(FcPattern* pattern, const char object[], int missing) {
     int value;
     if (FcPatternGetInteger(pattern, object, 0, &value) != FcResultMatch) {
         return missing;
     }
     return value;
 }
 
 static const char* get_string(FcPattern* pattern, const char object[], const char* missing = "") {
@@ skipping 39 matching lines @@
     if (result != FcResultMatch) {
         return kNoId_WeakReturn;
     }
     while (hasId) {
         hasId = FcPatternRemove(minimal, object, 1);
     }
 
     // Create a font set with two patterns.
     // 1. the same 'object' as minimal and a lang object with only 'nomatchlang'.
     // 2. a different 'object' from minimal and a lang object with only 'matchlang'.
-    SkAutoFcFontSet fontSet(FcFontSetCreate());
+    SkAutoFcFontSet fontSet;
 
-    SkAutoFcLangSet strongLangSet(FcLangSetCreate());
+    SkAutoFcLangSet strongLangSet;
     FcLangSetAdd(strongLangSet, (const FcChar8*)"nomatchlang");
     SkAutoFcPattern strong(FcPatternDuplicate(minimal));
     FcPatternAddLangSet(strong, FC_LANG, strongLangSet);
 
-    SkAutoFcLangSet weakLangSet(FcLangSetCreate());
+    SkAutoFcLangSet weakLangSet;
     FcLangSetAdd(weakLangSet, (const FcChar8*)"matchlang");
-    SkAutoFcPattern weak(FcPatternCreate());
+    SkAutoFcPattern weak;
     FcPatternAddString(weak, object, (const FcChar8*)"nomatchstring");
     FcPatternAddLangSet(weak, FC_LANG, weakLangSet);
 
     FcFontSetAdd(fontSet, strong.detach());
     FcFontSetAdd(fontSet, weak.detach());
 
     // Add 'matchlang' to the copy of the pattern.
     FcPatternAddLangSet(minimal, FC_LANG, weakLangSet);
 
     // Run a match against the copy of the pattern.
     // If the 'id' was weak, then we should match the pattern with 'matchlang'.
     // If the 'id' was strong, then we should match the pattern with 'nomatchlang'.
 
     // Note that this config is only used for FcFontRenderPrepare, which we don't even want.
     // However, there appears to be no way to match/sort without it.
-    SkAutoFcConfig config(FcConfigCreate());
+    SkAutoFcConfig config;
     FcFontSet* fontSets[1] = { fontSet };
     SkAutoFcPattern match(FcFontSetMatch(config, fontSets, SK_ARRAY_COUNT(fontSets),
                                          minimal, &result));
 
     FcLangSet* matchLangSet;
     FcPatternGetLangSet(match, FC_LANG, 0, &matchLangSet);
     return FcLangEqual == FcLangSetHasLang(matchLangSet, (const FcChar8*)"matchlang")
                         ? kIsWeak_WeakReturn : kIsStrong_WeakReturn;
 }
 
@@ skipping 272 matching lines @@
         virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
             FCLocker lock;
 
             FcPattern* match = fFontSet->fonts[index];
             return fFontMgr->createTypefaceFromFcPattern(match);
         }
 
         virtual SkTypeface* matchStyle(const SkFontStyle& style) SK_OVERRIDE {
             FCLocker lock;
 
-            SkAutoFcPattern pattern(FcPatternCreate());
-            if (NULL == pattern) {
-                return NULL;
-            }
-
+            SkAutoFcPattern pattern;
             fcpattern_from_skfontstyle(style, pattern);
             FcConfigSubstitute(fFontMgr->fFC, pattern, FcMatchPattern);
             FcDefaultSubstitute(pattern);
 
             FcResult result;
             FcFontSet* fontSets[1] = { fFontSet };
             SkAutoFcPattern match(FcFontSetMatch(fFontMgr->fFC,
                                                  fontSets, SK_ARRAY_COUNT(fontSets),
                                                  pattern, &result));
             if (NULL == match) {
@@ skipping 137 matching lines @@
                     continue;
                 }
                 if (0 == FcStrCmpIgnoreCase(patternString, fontString)) {
                     return true;
                 }
             }
         }
         return false;
     }
 
-    static bool ValidPattern(FcPattern* pattern) {
+    static bool FontAccessible(FcPattern* font) {
         // FontConfig can return fonts which are unreadable.
-        const char* filename = get_string(pattern, FC_FILE, NULL);
+        const char* filename = get_string(font, FC_FILE, NULL);
         if (NULL == filename) {
             return false;
         }
         return sk_exists(filename, kRead_SkFILE_Flag);
     }
 
-    static bool FontMatches(FcPattern* font, FcPattern* pattern) {
-        return ValidPattern(font) && AnyMatching(font, pattern, FC_FAMILY);
+    static bool FontFamilyNameMatches(FcPattern* font, FcPattern* pattern) {
+        return AnyMatching(font, pattern, FC_FAMILY);
+    }
+
+    static bool FontContainsCharacter(FcPattern* font, uint32_t character) {
+        FcResult result;
+        FcCharSet* matchCharSet;
+        for (int charSetId = 0; ; ++charSetId) {
+            result = FcPatternGetCharSet(font, FC_CHARSET, charSetId, &matchCharSet);
+            if (FcResultNoId == result) {
+                break;
+            }
+            if (FcResultMatch != result) {
+                continue;
+            }
+            if (FcCharSetHasChar(matchCharSet, character)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
         FCLocker lock;
 
-        SkAutoFcPattern pattern(FcPatternCreate());
-        if (NULL == pattern) {
-            return NULL;
-        }
-
+        SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         FcConfigSubstitute(fFC, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         FcPattern* matchPattern;
         SkAutoFcPattern strongPattern(NULL);
         if (familyName) {
             strongPattern.reset(FcPatternDuplicate(pattern));
             remove_weak(strongPattern, FC_FAMILY);
             matchPattern = strongPattern;
         } else {
             matchPattern = pattern;
         }
 
-        SkAutoFcFontSet matches(FcFontSetCreate());
+        SkAutoFcFontSet matches;
         // TODO: Some families have 'duplicates' due to symbolic links.
         // The patterns are exactly the same except for the FC_FILE.
         // It should be possible to collapse these patterns by normalizing.
         static const FcSetName fcNameSet[] = { FcSetSystem, FcSetApplication };
         for (int setIndex = 0; setIndex < (int)SK_ARRAY_COUNT(fcNameSet); ++setIndex) {
             // Return value of FcConfigGetFonts must not be destroyed.
             FcFontSet* allFonts(FcConfigGetFonts(fFC, fcNameSet[setIndex]));
             if (NULL == allFonts) {
                 continue;
             }
 
             for (int fontIndex = 0; fontIndex < allFonts->nfont; ++fontIndex) {
-                if (FontMatches(allFonts->fonts[fontIndex], matchPattern)) {
-                    FcFontSetAdd(matches,
-                                 FcFontRenderPrepare(fFC, pattern, allFonts->fonts[fontIndex]));
+                FcPattern* font = allFonts->fonts[fontIndex];
+                if (FontAccessible(font) && FontFamilyNameMatches(font, matchPattern)) {
+                    FcFontSetAdd(matches, FcFontRenderPrepare(fFC, pattern, font));
                 }
             }
         }
 
         return SkNEW_ARGS(StyleSet, (this, matches.detach()));
     }
 
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
                                            const SkFontStyle& style) const SK_OVERRIDE
     {
         FCLocker lock;
 
-        SkAutoFcPattern pattern(FcPatternCreate());
-        if (NULL == pattern) {
-            return NULL;
-        }
-
+        SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         fcpattern_from_skfontstyle(style, pattern);
         FcConfigSubstitute(fFC, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         // We really want to match strong (prefered) and same (acceptable) only here.
         // If a family name was specified, assume that any weak matches after the last strong match
         // are weak (default) and ignore them.
         // The reason for is that after substitution the pattern for 'sans-serif' looks like
         // "wwwwwwwwwwwwwwswww" where there are many weak but preferred names, followed by defaults.
         // So it is possible to have weakly matching but preferred names.
         // In aliases, bindings are weak by default, so this is easy and common.
         // If no family name was specified, we'll probably only get weak matches, but that's ok.
         FcPattern* matchPattern;
         SkAutoFcPattern strongPattern(NULL);
         if (familyName) {
             strongPattern.reset(FcPatternDuplicate(pattern));
             remove_weak(strongPattern, FC_FAMILY);
             matchPattern = strongPattern;
         } else {
             matchPattern = pattern;
         }
 
         FcResult result;
-        SkAutoFcPattern match(FcFontMatch(fFC, pattern, &result));
-        if (NULL == match || !FontMatches(match, matchPattern)) {
+        SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
+        if (NULL == font || !FontAccessible(font) || !FontFamilyNameMatches(font, matchPattern)) {
             return NULL;
         }
 
-        return createTypefaceFromFcPattern(match);
+        return createTypefaceFromFcPattern(font);
+    }
+
+    virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
+                                                    const SkFontStyle& style,
+                                                    const char bpc47[],
+                                                    uint32_t character) const SK_OVERRIDE
+    {
+        FCLocker lock;
+
+        SkAutoFcPattern pattern;
+        FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
+        fcpattern_from_skfontstyle(style, pattern);
+
+        SkAutoFcCharSet charSet;
+        FcCharSetAddChar(charSet, character);
+        FcPatternAddCharSet(pattern, FC_CHARSET, charSet);
+
+        if (bpc47) {
+            SkAutoFcLangSet langSet;
+            FcLangSetAdd(langSet, (const FcChar8*)bpc47);
+            FcPatternAddLangSet(pattern, FC_LANG, langSet);
+        }
+
+        FcConfigSubstitute(fFC, pattern, FcMatchPattern);
+        FcDefaultSubstitute(pattern);
+
+        FcResult result;
+        SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
+        if (NULL == font || !FontAccessible(font) || !FontContainsCharacter(font, character)) {
+            return NULL;
+        }
+
+        return createTypefaceFromFcPattern(font);
     }
 
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
                                          const SkFontStyle& style) const SK_OVERRIDE
     {
         //TODO: should the SkTypeface_fontconfig know its family?
         const SkTypeface_fontconfig* fcTypeface =
             static_cast<const SkTypeface_fontconfig*>(typeface);
         return this->matchFamilyStyle(get_string(fcTypeface->fPattern, FC_FAMILY), style);
     }
@@ skipping 39 matching lines @@
             return typeface.detach();
         }
 
         return this->matchFamilyStyle(NULL, style);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_fontconfig);
 }