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 88 matching lines @@
 template<typename T, void (*P)(T*)> void FcTDestroy(T* t) {
     FCLocker::AssertHeld();
     P(t);
 }
 template <typename T, void (*P)(T*)> class SkAutoFc
     : public SkAutoTCallVProc<T, FcTDestroy<T, P> > {
 public:
     SkAutoFc(T* obj) : SkAutoTCallVProc<T, FcTDestroy<T, P> >(obj) {}
 };
 
+typedef SkAutoFc<FcCharSet, FcCharSetDestroy> SkAutoFcCharSet;
 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;
 
 static int get_int(FcPattern* pattern, const char object[], int missing) {
     int value;
     if (FcPatternGetInteger(pattern, object, 0, &value) != FcResultMatch) {
         return missing;
@@ skipping 524 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) {

[mtklein, 2014/08/28 21:32:23]

// just a sanity check

[bungeman-skia, 2014/09/09 19:06:17]

Acknowledged.

+                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;
         }
 
@@ skipping 17 matching lines @@
         // 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
     {
@@ skipping 21 matching lines @@
         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[],

[mtklein, 2014/08/28 21:32:23]

/* may be NULL*/ ?

[bungeman-skia, 2014/09/09 19:06:17]

This sort of comment needs to be over in SkFontMgr.h. I'll keep it in mind.

+                                                    uint32_t character) const SK_OVERRIDE
+    {
+        FCLocker lock;
+
+        SkAutoFcPattern pattern(FcPatternCreate());
+        if (NULL == pattern) {

[mtklein, 2014/08/28 21:32:23]

add SkASSERT(pattern) ?

[bungeman-skia, 2014/09/09 19:06:17]

Done.

+            return NULL;
+        }
+
+        FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
+        fcpattern_from_skfontstyle(style, pattern);
+
+        SkAutoFcCharSet charSet(FcCharSetCreate());

[mtklein, 2014/08/28 21:32:23]

No null check?

[bungeman-skia, 2014/09/09 19:06:17]

Done.

+        FcCharSetAddChar(charSet, character);
+        FcPatternAddCharSet(pattern, FC_CHARSET, charSet);
+
+        if (bpc47) {
+            SkAutoFcLangSet langSet(FcLangSetCreate());

[mtklein, 2014/08/28 21:32:23]

...

[bungeman-skia, 2014/09/09 19:06:17]

Done.

+            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);
 }