Implement SkFontMgr_Android::onMatchFamilyStyleCharacter.

src/ports/SkFontConfigParser_android.cpp

 /*
  * Copyright 2011 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 "SkFontConfigParser_android.h"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
@@ skipping 14 matching lines @@
 // for now.
 #define NO_TAG 0
 #define NAMESET_TAG 1
 #define FILESET_TAG 2
 
 /**
  * The FamilyData structure is passed around by the parser so that each handler
  * can read these variables that are relevant to the current parsing.
  */
 struct FamilyData {
-    FamilyData(XML_Parser *parserRef, SkTDArray<FontFamily*> &familiesRef) :
-        parser(parserRef),
-        families(familiesRef),
-        currentFamily(NULL),
-        currentFontInfo(NULL),
-        currentTag(NO_TAG) {};
+    FamilyData(XML_Parser *parserRef,
+               SkTDArray<FontFamily*> &familiesRef,
+               uint32_t ignoredVariants)
+        : parser(parserRef)
+        , families(familiesRef)
+        , fIgnoredVariants(ignoredVariants)
+        , currentFamily(NULL)
+        , currentFontInfo(NULL)
+        , currentTag(NO_TAG) {};
 
     XML_Parser *parser;                // The expat parser doing the work
     SkTDArray<FontFamily*> &families;  // The array that each family is put into as it is parsed
+    uint32_t fIgnoredVariants;         // FontVariants which will be ignored.
     FontFamily *currentFamily;         // The current family being created
     FontFileInfo *currentFontInfo;     // The current fontInfo being created
     int currentTag;                    // A flag to indicate whether we're in nameset/fileset tags
 };
 
 /**
  * Handler for arbitrary text. This is used to parse the text inside each name
  * or file tag. The resulting strings are put into the fNames or FontFileInfo arrays.
  */
 static void textHandler(void *data, const char *s, int len) {
@@ skipping 68 matching lines @@
                 if (parseNonNegativeInteger(attributeValue, &value)) {
                     newFileInfo.fIndex = value;
                 } else {
                     SkDebugf("---- SystemFonts index=%s (INVALID)", attributeValue);
                 }
             }
             //each element is a pair of attributeName/attributeValue string pairs
             currentAttributeIndex += 2;
         }
     }
-    familyData->currentFontInfo = &newFileInfo;
+
+    if (SkToBool(newFileInfo.fPaintOptions.getFontVariant() & familyData->fIgnoredVariants)) {
+        familyData->currentFamily->fFontFiles.pop_back();
+        familyData->currentFontInfo = NULL;
+    } else {
+        familyData->currentFontInfo = &newFileInfo;
+    }
     XML_SetCharacterDataHandler(*familyData->parser, textHandler);
 }
 
 /**
  * Handler for the start of a tag. The only tags we expect are family, nameset,
  * fileset, name, and file.
  */
 static void startElementHandler(void *data, const char *tag, const char **atts) {
     FamilyData *familyData = (FamilyData*) data;
     int len = strlen(tag);
@@ skipping 42 matching lines @@
             (strncmp(tag, "file", len) == 0 && familyData->currentTag == FILESET_TAG)) {
         // Disable the arbitrary text handler installed to load Name data
         XML_SetCharacterDataHandler(*familyData->parser, NULL);
     }
 }
 
 /**
  * This function parses the given filename and stores the results in the given
  * families array.
  */
-static void parseConfigFile(const char *filename, SkTDArray<FontFamily*> &families) {
+static void parseConfigFile(const char *filename,
+                            SkTDArray<FontFamily*> &families,
+                            uint32_t ignoredVariants)

[djsollen, 2014/07/31 14:51:37]

ignoredVariants = 0;

[bungeman-skia, 2014/07/31 22:15:53]

Actually, I'm trying to follow the "as few default arguments as possible"
directive. I'll probably end up removing the default from the top level call as
well.

Also, I've removed this.

+{
 
     FILE* file = NULL;
 
 #if !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
     // if we are using a version of Android prior to Android 4.2 (JellyBean MR1
     // at API Level 17) then we need to look for files with a different suffix.
     char sdkVersion[PROP_VALUE_MAX];
     __system_property_get("ro.build.version.sdk", sdkVersion);
     const int sdkVersionInt = atoi(sdkVersion);
 
@@ skipping 22 matching lines @@
         file = fopen(filename, "r");
     }
 
     // Some of the files we attempt to parse (in particular, /vendor/etc/fallback_fonts.xml)
     // are optional - failure here is okay because one of these optional files may not exist.
     if (NULL == file) {
         return;
     }
 
     XML_Parser parser = XML_ParserCreate(NULL);
-    FamilyData *familyData = new FamilyData(&parser, families);
+    FamilyData *familyData = new FamilyData(&parser, families, ignoredVariants);
     XML_SetUserData(parser, familyData);
     XML_SetElementHandler(parser, startElementHandler, endElementHandler);
 
     char buffer[512];
     bool done = false;
     while (!done) {
         fgets(buffer, sizeof(buffer), file);
         int len = strlen(buffer);
         if (feof(file) != 0) {
             done = true;
         }
         XML_Parse(parser, buffer, len, done);
     }
     XML_ParserFree(parser);
     fclose(file);
 }
 
 static void getSystemFontFamilies(SkTDArray<FontFamily*> &fontFamilies) {
-    parseConfigFile(SYSTEM_FONTS_FILE, fontFamilies);
+    parseConfigFile(SYSTEM_FONTS_FILE, fontFamilies, 0);
 }
 
-static void getFallbackFontFamilies(SkTDArray<FontFamily*> &fallbackFonts) {
+static void getFallbackFontFamilies(SkTDArray<FontFamily*> &fallbackFonts,
+                                    uint32_t ignoredVariants)
+{
     SkTDArray<FontFamily*> vendorFonts;
-    parseConfigFile(FALLBACK_FONTS_FILE, fallbackFonts);
-    parseConfigFile(VENDOR_FONTS_FILE, vendorFonts);
+    parseConfigFile(FALLBACK_FONTS_FILE, fallbackFonts, ignoredVariants);
+    parseConfigFile(VENDOR_FONTS_FILE, vendorFonts, ignoredVariants);
 
     // This loop inserts the vendor fallback fonts in the correct order in the
     // overall fallbacks list.
     int currentOrder = -1;
     for (int i = 0; i < vendorFonts.count(); ++i) {
         FontFamily* family = vendorFonts[i];
         int order = family->order;
         if (order < 0) {
             if (currentOrder < 0) {
                 // Default case - just add it to the end of the fallback list
                 *fallbackFonts.append() = family;
             } else {
                 // no order specified on this font, but we're incrementing the order
                 // based on an earlier order insertion request
                 *fallbackFonts.insert(currentOrder++) = family;
             }
         } else {
             // Add the font into the fallback list in the specified order. Set
             // currentOrder for correct placement of other fonts in the vendor list.
             *fallbackFonts.insert(order) = family;
             currentOrder = order + 1;
         }
     }
 }
 
 /**
  * Loads data on font families from various expected configuration files. The
  * resulting data is returned in the given fontFamilies array.
  */
-void SkFontConfigParser::GetFontFamilies(SkTDArray<FontFamily*> &fontFamilies) {
-
+void SkFontConfigParser::GetFontFamilies(SkTDArray<FontFamily*> &fontFamilies,
+                                         uint32_t ignoredFallbackVariants)
+{
     getSystemFontFamilies(fontFamilies);
 
     // Append all the fallback fonts to system fonts
     SkTDArray<FontFamily*> fallbackFonts;
-    getFallbackFontFamilies(fallbackFonts);
+    getFallbackFontFamilies(fallbackFonts, ignoredFallbackVariants);
     for (int i = 0; i < fallbackFonts.count(); ++i) {
         fallbackFonts[i]->fIsFallbackFont = true;
         *fontFamilies.append() = fallbackFonts[i];
     }
 }
 
 void SkFontConfigParser::GetTestFontFamilies(SkTDArray<FontFamily*> &fontFamilies,
                                              const char* testMainConfigFile,
                                              const char* testFallbackConfigFile) {
-    parseConfigFile(testMainConfigFile, fontFamilies);
+    parseConfigFile(testMainConfigFile, fontFamilies, 0);
 
     SkTDArray<FontFamily*> fallbackFonts;
-    parseConfigFile(testFallbackConfigFile, fallbackFonts);
+    parseConfigFile(testFallbackConfigFile, fallbackFonts, 0);

[djsollen, 2014/07/31 14:51:37]

will this break Chromium?

[bungeman-skia, 2014/07/31 22:15:53]

Yes, I need to add the param here as well and fix up the current caller. Except
now I don't need to do anything, since it's been removed and this file is no
longer changing.

 
     // Append all fallback fonts to system fonts
     for (int i = 0; i < fallbackFonts.count(); ++i) {
         fallbackFonts[i]->fIsFallbackFont = true;
         *fontFamilies.append() = fallbackFonts[i];
     }
 }
 
 /**
  * Read the persistent locale.
@@ skipping 17 matching lines @@
     SkString locale(6);
     char* localeCStr = locale.writable_str();
 
     strncpy(localeCStr, propLang, 2);
     localeCStr[2] = '-';
     strncpy(&localeCStr[3], propRegn, 2);
     localeCStr[5] = '\0';
 
     return locale;
 }