The Tor Browser / file revision

 /*

  * 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 "SkTypeface.h"

 #include <expat.h>

 #include <stdio.h>

 #include <sys/system_properties.h>

 #define SYSTEM_FONTS_FILE "/system/etc/system_fonts.xml"

 #define FALLBACK_FONTS_FILE "/system/etc/fallback_fonts.xml"

 #define VENDOR_FONTS_FILE "/vendor/etc/fallback_fonts.xml"

 // These defines are used to determine the kind of tag that we're currently

 // populating with data. We only care about the sibling tags nameset and fileset

 // 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) {};

     XML_Parser *parser;                // The expat parser doing the work

     SkTDArray<FontFamily*> &families;  // The array that each family is put into as it is parsed

     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) {

     FamilyData *familyData = (FamilyData*) data;

     // Make sure we're in the right state to store this name information

     if (familyData->currentFamily &&

             (familyData->currentTag == NAMESET_TAG || familyData->currentTag == FILESET_TAG)) {

         // Malloc new buffer to store the string

         char *buff;

         buff = (char*) malloc((len + 1) * sizeof(char));

         strncpy(buff, s, len);

         buff[len] = '\0';

         switch (familyData->currentTag) {

         case NAMESET_TAG:

             *(familyData->currentFamily->fNames.append()) = buff;

             break;

         case FILESET_TAG:

             if (familyData->currentFontInfo) {

                 familyData->currentFontInfo->fFileName = buff;

             }

             break;

         default:

             // Noop - don't care about any text that's not in the Fonts or Names list

             break;

         }

     }

 }

 /**

  * Handler for font files. This processes the attributes for language and

  * variants then lets textHandler handle the actual file name

  */

 static void fontFileElementHandler(FamilyData *familyData, const char **attributes) {

     FontFileInfo* newFileInfo = new FontFileInfo();

     if (attributes) {

         int currentAttributeIndex = 0;

         while (attributes[currentAttributeIndex]) {

             const char* attributeName = attributes[currentAttributeIndex];

             const char* attributeValue = attributes[currentAttributeIndex+1];

             int nameLength = strlen(attributeName);

             int valueLength = strlen(attributeValue);

             if (strncmp(attributeName, "variant", nameLength) == 0) {

                 if (strncmp(attributeValue, "elegant", valueLength) == 0) {

                     newFileInfo->fPaintOptions.setFontVariant(SkPaintOptionsAndroid::kElegant_Variant);

                 } else if (strncmp(attributeValue, "compact", valueLength) == 0) {

                     newFileInfo->fPaintOptions.setFontVariant(SkPaintOptionsAndroid::kCompact_Variant);

                 }

             } else if (strncmp(attributeName, "lang", nameLength) == 0) {

                 newFileInfo->fPaintOptions.setLanguage(attributeValue);

             }

             //each element is a pair of attributeName/attributeValue string pairs

             currentAttributeIndex += 2;

         }

     }

     *(familyData->currentFamily->fFontFiles.append()) = newFileInfo;

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

     if (strncmp(tag, "family", len)== 0) {

         familyData->currentFamily = new FontFamily();

         familyData->currentFamily->order = -1;

         // The Family tag has an optional "order" attribute with an integer value >= 0

         // If this attribute does not exist, the default value is -1

         for (int i = 0; atts[i] != NULL; i += 2) {

             const char* valueString = atts[i+1];

             int value;

             int len = sscanf(valueString, "%d", &value);

             if (len > 0) {

                 familyData->currentFamily->order = value;

             }

         }

     } else if (len == 7 && strncmp(tag, "nameset", len) == 0) {

         familyData->currentTag = NAMESET_TAG;

     } else if (len == 7 && strncmp(tag, "fileset", len) == 0) {

         familyData->currentTag = FILESET_TAG;

     } else if (strncmp(tag, "name", len) == 0 && familyData->currentTag == NAMESET_TAG) {

         // If it's a Name, parse the text inside

         XML_SetCharacterDataHandler(*familyData->parser, textHandler);

     } else if (strncmp(tag, "file", len) == 0 && familyData->currentTag == FILESET_TAG) {

         // If it's a file, parse the attributes, then parse the text inside

         fontFileElementHandler(familyData, atts);

     }

 }

 /**

  * Handler for the end of tags. We only care about family, nameset, fileset,

  * name, and file.

  */

 static void endElementHandler(void *data, const char *tag) {

     FamilyData *familyData = (FamilyData*) data;

     int len = strlen(tag);

     if (strncmp(tag, "family", len)== 0) {

         // Done parsing a Family - store the created currentFamily in the families array

         *familyData->families.append() = familyData->currentFamily;

         familyData->currentFamily = NULL;

     } else if (len == 7 && strncmp(tag, "nameset", len) == 0) {

         familyData->currentTag = NO_TAG;

     } else if (len == 7 && strncmp(tag, "fileset", len) == 0) {

         familyData->currentTag = NO_TAG;

     } else if ((strncmp(tag, "name", len) == 0 && familyData->currentTag == NAMESET_TAG) ||

             (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) {

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

     if (0 != *sdkVersion && sdkVersionInt < 17) {

         SkString basename;

         SkString updatedFilename;

         SkString locale = SkFontConfigParser::GetLocale();

         basename.set(filename);

         // Remove the .xml suffix. We'll add it back in a moment.

         if (basename.endsWith(".xml")) {

             basename.resize(basename.size()-4);

         }

         // Try first with language and region

         updatedFilename.printf("%s-%s.xml", basename.c_str(), locale.c_str());

         file = fopen(updatedFilename.c_str(), "r");

         if (!file) {

             // If not found, try next with just language

             updatedFilename.printf("%s-%.2s.xml", basename.c_str(), locale.c_str());

             file = fopen(updatedFilename.c_str(), "r");

         }

     }

 #endif

     if (NULL == file) {

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

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

 }

 static void getFallbackFontFamilies(SkTDArray<FontFamily*> &fallbackFonts) {

     SkTDArray<FontFamily*> vendorFonts;

     parseConfigFile(FALLBACK_FONTS_FILE, fallbackFonts);

     parseConfigFile(VENDOR_FONTS_FILE, vendorFonts);

     // 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) {

     getSystemFontFamilies(fontFamilies);

     // Append all the fallback fonts to system fonts

     SkTDArray<FontFamily*> fallbackFonts;

     getFallbackFontFamilies(fallbackFonts);

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

     SkTDArray<FontFamily*> fallbackFonts;

     parseConfigFile(testFallbackConfigFile, fallbackFonts);

     // 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.

  */

 SkString SkFontConfigParser::GetLocale()

 {

     char propLang[PROP_VALUE_MAX], propRegn[PROP_VALUE_MAX];

     __system_property_get("persist.sys.language", propLang);

     __system_property_get("persist.sys.country", propRegn);

     if (*propLang == 0 && *propRegn == 0) {

         /* Set to ro properties, default is en_US */

         __system_property_get("ro.product.locale.language", propLang);

         __system_property_get("ro.product.locale.region", propRegn);

         if (*propLang == 0 && *propRegn == 0) {

             strcpy(propLang, "en");

             strcpy(propRegn, "US");

         }

     }

     SkString locale(6);

     char* localeCStr = locale.writable_str();

     strncpy(localeCStr, propLang, 2);

     localeCStr[2] = '-';

     strncpy(&localeCStr[3], propRegn, 2);

     localeCStr[5] = '\0';

     return locale;

 }