Use different unique identifier for a fallback family.

src/ports/SkFontConfigInterface_android.cpp

 
 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontConfigInterface.h"
 #include "SkTypeface_android.h"
@@ skipping 49 matching lines @@
 };
 
 struct FamilyRec {
     FamilyRec() {
         memset(fFontRecID, INVALID_FONT_REC_ID, sizeof(fFontRecID));
     }
 
     static const int FONT_STYLE_COUNT = 4;
     FontRecID fFontRecID[FONT_STYLE_COUNT];
     bool fIsFallbackFont;
+    SkString fFallbackName;
     SkPaintOptionsAndroid fPaintOptions;
 };
 
 
 typedef SkTDArray<FamilyRecID> FallbackFontList;
 
 class SkFontConfigInterfaceAndroid : public SkFontConfigInterface {
 public:
     SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies);
     virtual ~SkFontConfigInterfaceAndroid();
@@ skipping 176 matching lines @@
             // create a familyRec now that we know that at least one font in
             // the family is valid
             if (familyRec == NULL) {
                 familyRec = &fFontFamilies.push_back();
                 familyRecID = fFontFamilies.count() - 1;
                 fontRec.fFamilyRecID = familyRecID;
 
                 familyRec->fIsFallbackFont = family->fIsFallbackFont;
                 familyRec->fPaintOptions = family->fFontFiles[j]->fPaintOptions;
 
-                // if this is a fallback font then add it to the appropriate fallback chains
-                if (familyRec->fIsFallbackFont) {
-                    addFallbackFamily(familyRecID);
-                }
             } else if (familyRec->fPaintOptions != family->fFontFiles[j]->fPaintOptions) {
                 SkDebugf("Every font file within a family must have identical"
                          "language and variant attributes");
                 sk_throw();
             }
 
             // add this font to the current familyRec
             if (INVALID_FONT_REC_ID != familyRec->fFontRecID[fontRec.fStyle]) {
                 DEBUG_FONT(("Overwriting familyRec for style[%d] old,new:(%d,%d)",
                             fontRec.fStyle, familyRec->fFontRecID[fontRec.fStyle],
                             fontRecID));
             }
             familyRec->fFontRecID[fontRec.fStyle] = fontRecID;
+        }
 
-            // add the fallback file name to the name dictionary.  This is needed
-            // by getFallbackFamilyNameForChar() so that fallback families can be
-            // requested by the filenames of the fonts they contain.
-            if (familyRec && familyRec->fIsFallbackFont) {
-                insert_into_name_dict(fFamilyNameDict, fontRec.fFileName.c_str(), familyRecID);
+        if (familyRec) {
+            if (familyRec->fIsFallbackFont) {
+                // add the font to the appropriate fallback chains and also insert a
+                // unique name into the familyNameDict for internal usage
+                addFallbackFamily(familyRecID);
+            } else {
+                // add the names that map to this family to the dictionary for easy lookup
+                const SkTDArray<const char*>& names = family->fNames;
+                if (names.isEmpty()) {
+                    SkDEBUGFAIL("ERROR: non-fallback font with no name");
+                    continue;
+                }
+
+                for (int i = 0; i < names.count(); i++) {
+                    insert_into_name_dict(fFamilyNameDict, names[i], familyRecID);
+                }
             }
         }
-
-        // add the names that map to this family to the dictionary for easy lookup
-        if (familyRec && !familyRec->fIsFallbackFont) {
-            SkTDArray<const char*> names = family->fNames;
-            if (names.isEmpty()) {
-                SkDEBUGFAIL("ERROR: non-fallback font with no name");
-                continue;
-            }
-
-            for (int i = 0; i < names.count(); i++) {
-                insert_into_name_dict(fFamilyNameDict, names[i], familyRecID);
-            }
-        }
-
     }
 
     DEBUG_FONT(("---- We have %d system fonts", fFonts.count()));
 
     if (fFontFamilies.count() > 0) {
         fDefaultFamilyRecID = 0;
     }
 
     // scans the default fallback font chain, adding every entry to every other
     // fallback font chain to which it does not belong. this results in every
@@ skipping 19 matching lines @@
     // iterate through and cleanup fFallbackFontDict
     SkTDict<FallbackFontList*>::Iter iter(fFallbackFontDict);
     FallbackFontList* fallbackList;
     while(iter.next(&fallbackList) != NULL) {
         SkDELETE(fallbackList);
     }
 }
 
 void SkFontConfigInterfaceAndroid::addFallbackFamily(FamilyRecID familyRecID) {
     SkASSERT(familyRecID < fFontFamilies.count());
-    const FamilyRec& familyRec = fFontFamilies[familyRecID];
+    FamilyRec& familyRec = fFontFamilies[familyRecID];
     SkASSERT(familyRec.fIsFallbackFont);
 
+    // add the fallback family to the name dictionary.  This is
+    // needed by getFallbackFamilyNameForChar() so that fallback
+    // families can be identified by a unique name. The unique
+    // identifier that we've chosen is the familyID in hex (e.g. '0F##fallback').
+    familyRec.fFallbackName.printf("%.2x##fallback", familyRecID);
+    insert_into_name_dict(fFamilyNameDict, familyRec.fFallbackName.c_str(), familyRecID);
+
     // add to the default fallback list
     fDefaultFallbackList.push(familyRecID);
 
     // stop here if it is the default language tag
     const SkString& languageTag = familyRec.fPaintOptions.getLanguage().getTag();
     if (languageTag.isEmpty()) {
         return;
     }
 
     // add to the appropriate language's custom fallback list
@@ skipping 165 matching lines @@
         FontRecID fontRecID = find_best_style(fFontFamilies[familyRecID], SkTypeface::kNormal);
         SkTypeface* face = this->getTypefaceForFontRec(fontRecID);
 
         SkPaint paint;
         paint.setTypeface(face);
         paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
 
         uint16_t glyphID;
         paint.textToGlyphs(&uni, sizeof(uni), &glyphID);
         if (glyphID != 0) {
-            name->set(fFonts[fontRecID].fFileName);
+            name->set(fFontFamilies[familyRecID].fFallbackName);
             return true;
         }
     }
     return false;
 }
 
 SkTypeface* SkFontConfigInterfaceAndroid::getTypefaceForChar(SkUnichar uni,
                                                              SkTypeface::Style style,
                                                              SkPaintOptionsAndroid::FontVariant fontVariant) {
     FontRecID fontRecID = find_best_style(fFontFamilies[fDefaultFamilyRecID], style);
@@ skipping 308 matching lines @@
     return SkCreateTypefaceForScriptNG(getHBScriptFromHBScriptOld(script), style, fontVariant);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return NULL;
 }