fix regression in fallback chain where we don't account for the original font style.

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 37 matching lines @@
 #define INVALID_FONT_REC_ID -1
 
 typedef int32_t FamilyRecID;
 #define INVALID_FAMILY_REC_ID -1
 
 // used to record our notion of the pre-existing fonts
 struct FontRec {
     SkRefPtr<SkTypeface> fTypeface;
     SkString fFileName;
     SkTypeface::Style fStyle;
-    SkPaintOptionsAndroid fPaintOptions;
-    bool fIsFallbackFont;
     bool fIsValid;
     FamilyRecID fFamilyRecID;
 };
 
 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;
+    SkPaintOptionsAndroid fPaintOptions;
 };
 
 
-typedef SkTDArray<FontRecID> FallbackFontList;
+typedef SkTDArray<FamilyRecID> FallbackFontList;
 
 class SkFontConfigInterfaceAndroid : public SkFontConfigInterface {
 public:
     SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies);
     virtual ~SkFontConfigInterfaceAndroid();
 
     virtual bool matchFamilyName(const char familyName[],
                                  SkTypeface::Style requested,
                                  FontIdentity* outFontIdentifier,
                                  SkString* outFamilyName,
@@ skipping 13 matching lines @@
     bool getFallbackFamilyNameForChar(SkUnichar uni, SkString* name);
     /**
      *
      */
     SkTypeface* getTypefaceForChar(SkUnichar uni, SkTypeface::Style style,
                                    SkPaintOptionsAndroid::FontVariant fontVariant);
     SkTypeface* nextLogicalTypeface(SkFontID currFontID, SkFontID origFontID,
                                     const SkPaintOptionsAndroid& options);
 
 private:
-    void addFallbackFont(FontRecID fontRecID);
+    void addFallbackFamily(FamilyRecID fontRecID);
     SkTypeface* getTypefaceForFontRec(FontRecID fontRecID);
     FallbackFontList* getCurrentLocaleFallbackFontList();
     FallbackFontList* findFallbackFontList(const SkLanguage& lang, bool isOriginal = true);
 
     SkTArray<FontRec> fFonts;
     SkTArray<FamilyRec> fFontFamilies;
     SkTDict<FamilyRecID> fFamilyNameDict;
     FamilyRecID fDefaultFamilyRecID;
 
     // (SkLanguage)<->(fallback chain index) translation
@@ skipping 101 matching lines @@
 
             if (has_font(fFonts, filename)) {
                 SkDebugf("---- system font and fallback font files specify a duplicate "
                         "font %s, skipping the second occurrence", filename.c_str());
                 continue;
             }
 
             FontRec& fontRec = fFonts.push_back();
             fontRec.fFileName = filename;
             fontRec.fStyle = SkTypeface::kNormal;
-            fontRec.fPaintOptions = family->fFontFiles[j]->fPaintOptions;
-            fontRec.fIsFallbackFont = family->fIsFallbackFont;
             fontRec.fIsValid = false;
             fontRec.fFamilyRecID = familyRecID;
 
             const FontRecID fontRecID = fFonts.count() - 1;
 
             SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(filename.c_str()));
             if (stream.get() != NULL) {
                 bool isFixedWidth;
                 SkString name;
                 fontRec.fIsValid = find_name_and_attributes(stream.get(), &name,
                                                             &fontRec.fStyle, &isFixedWidth);
             } else {
-                if (!fontRec.fIsFallbackFont) {
+                if (!family->fIsFallbackFont) {
                     SkDebugf("---- failed to open <%s> as a font\n", filename.c_str());
                 }
             }
 
             if (fontRec.fIsValid) {
                 DEBUG_FONT(("---- SystemFonts[%d][%d] fallback=%d file=%s",
                            i, fFonts.count() - 1, fontRec.fIsFallbackFont, filename.c_str()));
             } else {
                 DEBUG_FONT(("---- SystemFonts[%d][%d] fallback=%d file=%s (INVALID)",
                            i, fFonts.count() - 1, fontRec.fIsFallbackFont, filename.c_str()));
                 continue;
             }
 
             // 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;
 
-            // if this is a fallback font then add it to the appropriate fallback chains
-            if (fontRec.fIsFallbackFont) {
-                addFallbackFont(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 (family->fIsFallbackFont && familyRec) {
+            if (familyRec && familyRec->fIsFallbackFont) {
                 insert_into_name_dict(fFamilyNameDict, fontRec.fFileName.c_str(), familyRecID);
             }
         }
 
         // add the names that map to this family to the dictionary for easy lookup
-        if (familyRec && !family->fIsFallbackFont) {
+        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
     // language-specific fallback font chain having all of its fallback fonts at
     // the front of the chain, and everything else at the end.
     FallbackFontList* fallbackList;
     SkTDict<FallbackFontList*>::Iter iter(fFallbackFontDict);
     const char* fallbackLang = iter.next(&fallbackList);
     while(fallbackLang != NULL) {
         for (int i = 0; i < fDefaultFallbackList.count(); i++) {
-            FontRecID fontRecID = fDefaultFallbackList[i];
-            const SkString& fontLang = fFonts[fontRecID].fPaintOptions.getLanguage().getTag();
+            FamilyRecID familyRecID = fDefaultFallbackList[i];
+            const SkString& fontLang = fFontFamilies[familyRecID].fPaintOptions.getLanguage().getTag();
             if (strcmp(fallbackLang, fontLang.c_str()) != 0) {
-                fallbackList->push(fontRecID);
+                fallbackList->push(familyRecID);
             }
         }
         // move to the next fallback list in the dictionary
         fallbackLang = iter.next(&fallbackList);
     }
 }
 
 SkFontConfigInterfaceAndroid::~SkFontConfigInterfaceAndroid() {
     // iterate through and cleanup fFallbackFontDict
     SkTDict<FallbackFontList*>::Iter iter(fFallbackFontDict);
     FallbackFontList* fallbackList;
     while(iter.next(&fallbackList) != NULL) {
         SkDELETE(fallbackList);
     }
 }
 
-void SkFontConfigInterfaceAndroid::addFallbackFont(FontRecID fontRecID) {
-    SkASSERT(fontRecID < fFonts.count());
-    const FontRec& fontRec = fFonts[fontRecID];
-    SkASSERT(fontRec.fIsFallbackFont);
+void SkFontConfigInterfaceAndroid::addFallbackFamily(FamilyRecID familyRecID) {
+    SkASSERT(familyRecID < fFontFamilies.count());
+    const FamilyRec& familyRec = fFontFamilies[familyRecID];
+    SkASSERT(familyRec.fIsFallbackFont);
 
     // add to the default fallback list
-    fDefaultFallbackList.push(fontRecID);
+    fDefaultFallbackList.push(familyRecID);
 
     // stop here if it is the default language tag
-    const SkString& languageTag = fontRec.fPaintOptions.getLanguage().getTag();
+    const SkString& languageTag = familyRec.fPaintOptions.getLanguage().getTag();
     if (languageTag.isEmpty()) {
         return;
     }
 
     // add to the appropriate language's custom fallback list
     FallbackFontList* customList = NULL;
     if (!fFallbackFontDict.find(languageTag.c_str(), &customList)) {
         DEBUG_FONT(("----  Created fallback list for \"%s\"", languageTag.c_str()));
         customList = SkNEW(FallbackFontList);
         fFallbackFontDict.set(languageTag.c_str(), customList);
     }
     SkASSERT(customList != NULL);
-    customList->push(fontRecID);
+    customList->push(familyRecID);
 }
 
 
 static FontRecID find_best_style(const FamilyRec& family, SkTypeface::Style style) {
 
     const FontRecID* fontRecIDs = family.fFontRecID;
 
     if (fontRecIDs[style] != INVALID_FONT_REC_ID) { // exact match
         return fontRecIDs[style];
     }
@@ skipping 125 matching lines @@
         // store the result for subsequent lookups
         fontRec.fTypeface = face;
     }
     SkASSERT(face);
     return face;
 }
 
 bool SkFontConfigInterfaceAndroid::getFallbackFamilyNameForChar(SkUnichar uni, SkString* name) {
     FallbackFontList* fallbackFontList = this->getCurrentLocaleFallbackFontList();
     for (int i = 0; i < fallbackFontList->count(); i++) {
-        FontRecID fontRecID = fallbackFontList->getAt(i);
+        FamilyRecID familyRecID = fallbackFontList->getAt(i);
+        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);
@@ skipping 70 matching lines @@
     // as WebKit to customize their font selection. In any case, clients can use
     // GetFallbackFamilyNameForChar() to get the fallback font for individual
     // characters.
     if (!opts.isUsingFontFallbacks()) {
         return NULL;
     }
 
     FallbackFontList* currentFallbackList = findFallbackFontList(opts.getLanguage());
     SkASSERT(currentFallbackList);
 
+    SkTypeface::Style origStyle = SkTypeface::kNormal;
+    const SkTypeface* origTypeface = SkTypefaceCache::FindByID(origFontID);
+    if (NULL != origTypeface) {
+        origStyle = origTypeface->style();
+    }
+
     // we must convert currTypeface into a FontRecID
     FontRecID currFontRecID = INVALID_FONT_REC_ID;
     const SkTypeface* currTypeface = SkTypefaceCache::FindByID(currFontID);
     // non-system fonts are not in the font cache so if we are asked to fallback
     // for a non-system font we will start at the front of the chain.
     if (NULL != currTypeface && currFontID != origFontID) {
         currFontRecID = ((FontConfigTypeface*)currTypeface)->getIdentity().fID;
         SkASSERT(INVALID_FONT_REC_ID != currFontRecID);
     }
 
+    FamilyRecID currFamilyRecID = INVALID_FAMILY_REC_ID;
+    if (INVALID_FONT_REC_ID != currFontRecID) {
+        currFamilyRecID = fFonts[currFontRecID].fFamilyRecID;
+    }
+
     // lookup the index next font in the chain
-    int currFallbackFontIndex = currentFallbackList->find(currFontRecID);
+    int currFallbackFontIndex = currentFallbackList->find(currFamilyRecID);
     // We add 1 to the returned index for 2 reasons: (1) if find succeeds it moves
     // our index to the next entry in the list; (2) if find() fails it returns
     // -1 and incrementing it will set our starting index to 0 (the head of the list)
     int nextFallbackFontIndex = currFallbackFontIndex + 1;
 
     if(nextFallbackFontIndex >= currentFallbackList->count()) {
         return NULL;
     }
 
     // If a rec object is set to prefer "kDefault_Variant" it means they have no preference
     // In this case, we set the value to "kCompact_Variant"
     SkPaintOptionsAndroid::FontVariant variant = opts.getFontVariant();
     if (variant == SkPaintOptionsAndroid::kDefault_Variant) {
         variant = SkPaintOptionsAndroid::kCompact_Variant;
     }
 
     int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant | variant;
 
     SkTypeface* nextLogicalTypeface = 0;
     while (nextFallbackFontIndex < currentFallbackList->count()) {
-        FontRecID fontRecID = currentFallbackList->getAt(nextFallbackFontIndex);
-        if ((fFonts[fontRecID].fPaintOptions.getFontVariant() & acceptedVariants) != 0) {
-            nextLogicalTypeface = this->getTypefaceForFontRec(fontRecID);
+        FamilyRecID familyRecID = currentFallbackList->getAt(nextFallbackFontIndex);
+        if ((fFontFamilies[familyRecID].fPaintOptions.getFontVariant() & acceptedVariants) != 0) {
+            FontRecID matchedFont = find_best_style(fFontFamilies[familyRecID], origStyle);
+            nextLogicalTypeface = this->getTypefaceForFontRec(matchedFont);
             break;
         }
         nextFallbackFontIndex++;
     }
 
     DEBUG_FONT(("---- nextLogicalFont: currFontID=%d, origFontID=%d, currRecID=%d, "
                 "lang=%s, variant=%d, nextFallbackIndex[%d,%d] => nextLogicalTypeface=%d",
                 currFontID, origFontID, currFontRecID, opts.getLanguage().getTag().c_str(),
                 variant, nextFallbackFontIndex, currentFallbackList->getAt(nextFallbackFontIndex),
                 (nextLogicalTypeface) ? nextLogicalTypeface->uniqueID() : 0));
@@ skipping 175 matching lines @@
     return SkCreateTypefaceForScriptNG(getHBScriptFromHBScriptOld(script), style, fontVariant);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return NULL;
 }