Revert "Remove SkPaintOptionsAndroid"

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 51 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;
-    SkLanguage fLanguage;
-    FontVariant fVariant;
+    SkPaintOptionsAndroid fPaintOptions;
 };
 
 
 typedef SkTDArray<FamilyRecID> FallbackFontList;
 
 class SkFontConfigInterfaceAndroid : public SkFontConfigInterface {
 public:
     SkFontConfigInterfaceAndroid(SkTDArray<FontFamily*>& fontFamilies);
     virtual ~SkFontConfigInterfaceAndroid();
 
@@ skipping 162 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->fLanguage = family->fLanguage;
-                familyRec->fVariant = family->fVariant;
+                familyRec->fPaintOptions = family->fFontFiles[j].fPaintOptions;
+
+            } 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;
         }
@@ skipping 27 matching lines @@
     // 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++) {
             FamilyRecID familyRecID = fDefaultFallbackList[i];
-            const SkString& fontLang = fFontFamilies[familyRecID].fLanguage.getTag();
+            const SkString& fontLang = fFontFamilies[familyRecID].fPaintOptions.getLanguage().getTag();
             if (strcmp(fallbackLang, fontLang.c_str()) != 0) {
                 fallbackList->push(familyRecID);
             }
         }
         // move to the next fallback list in the dictionary
         fallbackLang = iter.next(&fallbackList);
     }
 }
 
 SkFontConfigInterfaceAndroid::~SkFontConfigInterfaceAndroid() {
@@ skipping 14 matching lines @@
     // 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.fLanguage.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);
@@ skipping 150 matching lines @@
     if (NULL == fLocaleFallbackFontList || locale != fCachedLocale) {
         fCachedLocale = locale;
         fLocaleFallbackFontList = this->findFallbackFontList(locale);
     }
     FallbackFontList* fallbackFontList = fLocaleFallbackFontList;
 
     for (int i = 0; i < fallbackFontList->count(); i++) {
         FamilyRecID familyRecID = fallbackFontList->getAt(i);
 
         // if it is not one of the accepted variants then move to the next family
-        int32_t acceptedVariants = kDefault_FontVariant |
-                                   kElegant_FontVariant;
-        if (!(fFontFamilies[familyRecID].fVariant & acceptedVariants)) {
+        int32_t acceptedVariants = SkPaintOptionsAndroid::kDefault_Variant |
+                                   SkPaintOptionsAndroid::kElegant_Variant;
+        if (!(fFontFamilies[familyRecID].fPaintOptions.getFontVariant() & acceptedVariants)) {
             continue;
         }
 
         FontRecID fontRecID = find_best_style(fFontFamilies[familyRecID], SkTypeface::kNormal);
         SkTypeface* face = this->getTypefaceForFontRec(fontRecID);
 
         SkPaint paint;
         paint.setTypeface(face);
         paint.setTextEncoding(SkPaint::kUTF32_TextEncoding);
 
@@ skipping 43 matching lines @@
                              const char* fontsdir) {
     gTestMainConfigFile = mainconf;
     gTestFallbackConfigFile = fallbackconf;
     gTestFontFilePrefix = fontsdir;
     SkASSERT(gTestMainConfigFile);
     SkASSERT(gTestFallbackConfigFile);
     SkASSERT(gTestFontFilePrefix);
     SkDEBUGF(("Use Test Config File Main %s, Fallback %s, Font Dir %s",
               gTestMainConfigFile, gTestFallbackConfigFile, gTestFontFilePrefix));
 }