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 "SkFontMgr_android.h"
#include "SkStream.h"
#include "SkTDArray.h"
#include "SkTSearch.h"
#include "SkTypeface.h"

#include <expat.h>
#include <dirent.h>
#include <stdio.h>

#include <limits>
#include <stdlib.h>

// From Android version LMP onwards, all font files collapse into
// /system/etc/fonts.xml. Instead of trying to detect which version
// we're on, try to open fonts.xml; if that fails, fall back to the
// older filename.
#define LMP_SYSTEM_FONTS_FILE "/system/etc/fonts.xml"
#define OLD_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"

#define LOCALE_FALLBACK_FONTS_SYSTEM_DIR "/system/etc"
#define LOCALE_FALLBACK_FONTS_VENDOR_DIR "/vendor/etc"
#define LOCALE_FALLBACK_FONTS_PREFIX "fallback_fonts-"
#define LOCALE_FALLBACK_FONTS_SUFFIX ".xml"

#ifndef SK_FONT_FILE_PREFIX
#    define SK_FONT_FILE_PREFIX "/fonts/"
#endif

/**
 * This file contains TWO parsers: one for JB and earlier (system_fonts.xml /
 * fallback_fonts.xml), one for LMP and later (fonts.xml).
 * We start with the JB parser, and if we detect a <familyset> tag with
 * version 21 or higher we switch to the LMP parser.
 */

/** Used to track which tag is currently populating with data.
 *  Only nameset and fileset are of interest for now.
 */
enum CurrentTag {
    kNo_CurrentTag,
    kNameSet_CurrentTag,
    kFileSet_CurrentTag
};

/**
 * 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 parser, SkTDArray<FontFamily*>& families,
               const SkString& basePath, bool isFallback)
        : fParser(parser)
        , fFamilies(families)
        , fCurrentFamily(NULL)
        , fCurrentFontInfo(NULL)
        , fCurrentTag(kNo_CurrentTag)
        , fVersion(0)
        , fBasePath(basePath)
        , fIsFallback(isFallback)
    { };

    XML_Parser fParser;                       // The expat parser doing the work, owned by caller
    SkTDArray<FontFamily*>& fFamilies;        // The array to append families, owned by caller
    SkAutoTDelete<FontFamily> fCurrentFamily; // The family being created, owned by this
    FontFileInfo* fCurrentFontInfo;           // The fontInfo being created, owned by fCurrentFamily
    CurrentTag fCurrentTag;                   // The kind of tag currently being parsed.
    int fVersion;                             // The version of the file parsed.
    const SkString& fBasePath;                // The current base path.
    const bool fIsFallback;                   // Indicates the file being parsed is a fallback file
};

/** Parses a null terminated string into an integer type, checking for overflow.
 *  http://www.w3.org/TR/html-markup/datatypes.html#common.data.integer.non-negative-def
 *
 *  If the string cannot be parsed into 'value', returns false and does not change 'value'.
 */
template <typename T> static bool parse_non_negative_integer(const char* s, T* value) {
    SK_COMPILE_ASSERT(std::numeric_limits<T>::is_integer, T_must_be_integer);
    const T nMax = std::numeric_limits<T>::max() / 10;
    const T dMax = std::numeric_limits<T>::max() - (nMax * 10);
    T n = 0;
    for (; *s; ++s) {
        // Check if digit
        if (*s < '0' || '9' < *s) {
            return false;
        }
        int d = *s - '0';
        // Check for overflow
        if (n > nMax || (n == nMax && d > dMax)) {
            return false;
        }
        n = (n * 10) + d;
    }
    *value = n;
    return true;
}

static bool memeq(const char* s1, const char* s2, size_t n1, size_t n2) {
    return n1 == n2 && 0 == memcmp(s1, s2, n1);
}
#define MEMEQ(c, s, n) memeq(c, s, sizeof(c) - 1, n)

#define ATTS_NON_NULL(a, i) (a[i] != NULL && a[i+1] != NULL)

namespace lmpParser {

static void family_element_handler(FontFamily* family, const char** attributes) {
    // A non-fallback <family> tag must have a canonical name attribute.
    // A fallback <family> tag has no name, and may have lang and variant
    // attributes.
    family->fIsFallbackFont = true;
    for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
        const char* name = attributes[i];
        const char* value = attributes[i+1];
        size_t nameLen = strlen(name);
        size_t valueLen = strlen(value);
        if (MEMEQ("name", name, nameLen)) {
            SkAutoAsciiToLC tolc(value);
            family->fNames.push_back().set(tolc.lc());
            family->fIsFallbackFont = false;
        } else if (MEMEQ("lang", name, nameLen)) {
            family->fLanguage = SkLanguage(value, valueLen);
        } else if (MEMEQ("variant", name, nameLen)) {
            // Value should be either elegant or compact.
            if (MEMEQ("elegant", value, valueLen)) {
                family->fVariant = kElegant_FontVariant;
            } else if (MEMEQ("compact", value, valueLen)) {
                family->fVariant = kCompact_FontVariant;
            }
        }
    }
}

static void XMLCALL font_file_name_handler(void* data, const char* s, int len) {
    FamilyData* self = static_cast<FamilyData*>(data);
    self->fCurrentFontInfo->fFileName.append(s, len);
}

static void font_element_handler(FamilyData* self, FontFileInfo* file, const char** attributes) {
    // A <font> should have weight (integer) and style (normal, italic) attributes.
    // NOTE: we ignore the style.
    // The element should contain a filename.
    for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
        const char* name = attributes[i];
        const char* value = attributes[i+1];
        size_t nameLen = strlen(name);
        if (MEMEQ("weight", name, nameLen)) {
            if (!parse_non_negative_integer(value, &file->fWeight)) {
                SkDebugf("---- Font weight %s (INVALID)", value);
            }
        }
    }
    XML_SetCharacterDataHandler(self->fParser, font_file_name_handler);
}

static FontFamily* find_family(FamilyData* self, const SkString& familyName) {
    for (int i = 0; i < self->fFamilies.count(); i++) {
        FontFamily* candidate = self->fFamilies[i];
        for (int j = 0; j < candidate->fNames.count(); j++) {
            if (candidate->fNames[j] == familyName) {
                return candidate;
            }
        }
    }
    return NULL;
}

static void alias_element_handler(FamilyData* self, const char** attributes) {
    // An <alias> must have name and to attributes.
    //   It may have weight (integer).
    // If it *does not* have a weight, it is a variant name for a <family>.
    // If it *does* have a weight, it names the <font>(s) of a specific weight
    //   from a <family>.

    SkString aliasName;
    SkString to;
    int weight = 0;
    for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
        const char* name = attributes[i];
        const char* value = attributes[i+1];
        size_t nameLen = strlen(name);
        if (MEMEQ("name", name, nameLen)) {
            SkAutoAsciiToLC tolc(value);
            aliasName.set(tolc.lc());
        } else if (MEMEQ("to", name, nameLen)) {
            to.set(value);
        } else if (MEMEQ("weight", name, nameLen)) {
            if (!parse_non_negative_integer(value, &weight)) {
                SkDebugf("---- Font weight %s (INVALID)", value);
            }
        }
    }

    // Assumes that the named family is already declared
    FontFamily* targetFamily = find_family(self, to);
    if (!targetFamily) {
        SkDebugf("---- Font alias target %s (NOT FOUND)", to.c_str());
        return;
    }

    if (weight) {
        FontFamily* family = new FontFamily(targetFamily->fBasePath, self->fIsFallback);
        family->fNames.push_back().set(aliasName);

        for (int i = 0; i < targetFamily->fFonts.count(); i++) {
            if (targetFamily->fFonts[i].fWeight == weight) {
                family->fFonts.push_back(targetFamily->fFonts[i]);
            }
        }
        *self->fFamilies.append() = family;
    } else {
        targetFamily->fNames.push_back().set(aliasName);
    }
}

static void XMLCALL start_element_handler(void* data, const char* tag, const char** attributes) {
    FamilyData* self = static_cast<FamilyData*>(data);
    size_t len = strlen(tag);
    if (MEMEQ("family", tag, len)) {
        self->fCurrentFamily.reset(new FontFamily(self->fBasePath, self->fIsFallback));
        family_element_handler(self->fCurrentFamily, attributes);
    } else if (MEMEQ("font", tag, len)) {
        FontFileInfo* file = &self->fCurrentFamily->fFonts.push_back();
        self->fCurrentFontInfo = file;
        font_element_handler(self, file, attributes);
    } else if (MEMEQ("alias", tag, len)) {
        alias_element_handler(self, attributes);
    }
}

static void XMLCALL end_element_handler(void* data, const char* tag) {
    FamilyData* self = static_cast<FamilyData*>(data);
    size_t len = strlen(tag);
    if (MEMEQ("family", tag, len)) {
        *self->fFamilies.append() = self->fCurrentFamily.detach();
    } else if (MEMEQ("font", tag, len)) {
        XML_SetCharacterDataHandler(self->fParser, NULL);
    }
}

} // lmpParser

namespace jbParser {

/**
 * 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 XMLCALL text_handler(void* data, const char* s, int len) {
    FamilyData* self = static_cast<FamilyData*>(data);
    // Make sure we're in the right state to store this name information
    if (self->fCurrentFamily.get()) {
        switch (self->fCurrentTag) {
        case kNameSet_CurrentTag: {
            SkAutoAsciiToLC tolc(s, len);
            self->fCurrentFamily->fNames.back().append(tolc.lc(), len);
            break;
        }
        case kFileSet_CurrentTag:
            if (self->fCurrentFontInfo) {
                self->fCurrentFontInfo->fFileName.append(s, len);
            }
            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 font_file_element_handler(FamilyData* self, const char** attributes) {
    FontFamily& currentFamily = *self->fCurrentFamily.get();
    FontFileInfo& newFileInfo = currentFamily.fFonts.push_back();
    if (attributes) {
        for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
            const char* attributeName = attributes[i];
            const char* attributeValue = attributes[i+1];
            size_t nameLength = strlen(attributeName);
            size_t valueLength = strlen(attributeValue);
            if (MEMEQ("variant", attributeName, nameLength)) {
                const FontVariant prevVariant = currentFamily.fVariant;
                if (MEMEQ("elegant", attributeValue, valueLength)) {
                    currentFamily.fVariant = kElegant_FontVariant;
                } else if (MEMEQ("compact", attributeValue, valueLength)) {
                    currentFamily.fVariant = kCompact_FontVariant;
                }
                if (currentFamily.fFonts.count() > 1 && currentFamily.fVariant != prevVariant) {
                    SkDebugf("Every font file within a family must have identical variants");
                }

            } else if (MEMEQ("lang", attributeName, nameLength)) {
                SkLanguage prevLang = currentFamily.fLanguage;
                currentFamily.fLanguage = SkLanguage(attributeValue, valueLength);
                if (currentFamily.fFonts.count() > 1 && currentFamily.fLanguage != prevLang) {
                    SkDebugf("Every font file within a family must have identical languages");
                }

            } else if (MEMEQ("index", attributeName, nameLength)) {
                if (!parse_non_negative_integer(attributeValue, &newFileInfo.fIndex)) {
                    SkDebugf("---- SystemFonts index=%s (INVALID)", attributeValue);
                }
            }
        }
    }
    self->fCurrentFontInfo = &newFileInfo;
    XML_SetCharacterDataHandler(self->fParser, text_handler);
}

/**
 * Handler for the start of a tag. The only tags we expect are familyset, family,
 * nameset, fileset, name, and file.
 */
static void XMLCALL start_element_handler(void* data, const char* tag, const char** attributes) {
    FamilyData* self = static_cast<FamilyData*>(data);
    size_t len = strlen(tag);
    if (MEMEQ("familyset", tag, len)) {
        // The familyset tag has an optional "version" attribute with an integer value >= 0
        for (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
            size_t nameLen = strlen(attributes[i]);
            if (!MEMEQ("version", attributes[i], nameLen)) continue;
            const char* valueString = attributes[i+1];
            int version;
            if (parse_non_negative_integer(valueString, &version) && (version >= 21)) {
                XML_SetElementHandler(self->fParser,
                                      lmpParser::start_element_handler,
                                      lmpParser::end_element_handler);
                self->fVersion = version;
            }
        }
    } else if (MEMEQ("family", tag, len)) {
        self->fCurrentFamily.reset(new FontFamily(self->fBasePath, self->fIsFallback));
        // 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 (size_t i = 0; ATTS_NON_NULL(attributes, i); i += 2) {
            const char* valueString = attributes[i+1];
            int value;
            if (parse_non_negative_integer(valueString, &value)) {
                self->fCurrentFamily->fOrder = value;
            }
        }
    } else if (MEMEQ("nameset", tag, len)) {
        self->fCurrentTag = kNameSet_CurrentTag;
    } else if (MEMEQ("fileset", tag, len)) {
        self->fCurrentTag = kFileSet_CurrentTag;
    } else if (MEMEQ("name", tag, len) && self->fCurrentTag == kNameSet_CurrentTag) {
        // If it's a Name, parse the text inside
        self->fCurrentFamily->fNames.push_back();
        XML_SetCharacterDataHandler(self->fParser, text_handler);
    } else if (MEMEQ("file", tag, len) && self->fCurrentTag == kFileSet_CurrentTag) {
        // If it's a file, parse the attributes, then parse the text inside
        font_file_element_handler(self, attributes);
    }
}

/**
 * Handler for the end of tags. We only care about family, nameset, fileset,
 * name, and file.
 */
static void XMLCALL end_element_handler(void* data, const char* tag) {
    FamilyData* self = static_cast<FamilyData*>(data);
    size_t len = strlen(tag);
    if (MEMEQ("family", tag, len)) {
        // Done parsing a Family - store the created currentFamily in the families array
        *self->fFamilies.append() = self->fCurrentFamily.detach();
    } else if (MEMEQ("nameset", tag, len)) {
        self->fCurrentTag = kNo_CurrentTag;
    } else if (MEMEQ("fileset", tag, len)) {
        self->fCurrentTag = kNo_CurrentTag;
    } else if ((MEMEQ("name", tag, len) && self->fCurrentTag == kNameSet_CurrentTag) ||
               (MEMEQ("file", tag, len) && self->fCurrentTag == kFileSet_CurrentTag)) {
        // Disable the arbitrary text handler installed to load Name data
        XML_SetCharacterDataHandler(self->fParser, NULL);
    }
}

} // namespace jbParser

static void XMLCALL xml_entity_decl_handler(void *data,
                                            const XML_Char *entityName,
                                            int is_parameter_entity,
                                            const XML_Char *value,
                                            int value_length,
                                            const XML_Char *base,
                                            const XML_Char *systemId,
                                            const XML_Char *publicId,
                                            const XML_Char *notationName)
{
    FamilyData* self = static_cast<FamilyData*>(data);
    SkDebugf("Entity declaration %s found, stopping processing.", entityName);
    XML_StopParser(self->fParser, XML_FALSE);
}

static const XML_Memory_Handling_Suite sk_XML_alloc = {
    sk_malloc_throw,
    sk_realloc_throw,
    sk_free
};

template<typename T> struct remove_ptr {typedef T type;};
template<typename T> struct remove_ptr<T*> {typedef T type;};

/**
 * This function parses the given filename and stores the results in the given
 * families array. Returns the version of the file, negative if the file does not exist.
 */
static int parse_config_file(const char* filename, SkTDArray<FontFamily*>& families,
                             const SkString& basePath, bool isFallback)
{
    SkFILEStream file(filename);

    // 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 (!file.isValid()) {
        SkDebugf("File %s could not be opened.\n", filename);
        return -1;
    }

    SkAutoTCallVProc<remove_ptr<XML_Parser>::type, XML_ParserFree> parser(
        XML_ParserCreate_MM(NULL, &sk_XML_alloc, NULL));
    if (!parser) {
        SkDebugf("Could not create XML parser.\n");
        return -1;
    }

    FamilyData self(parser, families, basePath, isFallback);
    XML_SetUserData(parser, &self);

    // Disable entity processing, to inhibit internal entity expansion. See expat CVE-2013-0340
    XML_SetEntityDeclHandler(parser, xml_entity_decl_handler);

    // Start parsing oldschool; switch these in flight if we detect a newer version of the file.
    XML_SetElementHandler(parser, jbParser::start_element_handler, jbParser::end_element_handler);

    // One would assume it would be faster to have a buffer on the stack and call XML_Parse.
    // But XML_Parse will call XML_GetBuffer anyway and memmove the passed buffer into it.
    // (Unless XML_CONTEXT_BYTES is undefined, but all users define it.)
    // In debug, buffer a small odd number of bytes to detect slicing in XML_CharacterDataHandler.
    static const int bufferSize = 512 SkDEBUGCODE( - 507);
    bool done = false;
    while (!done) {
        void* buffer = XML_GetBuffer(parser, bufferSize);
        if (!buffer) {
            SkDebugf("Could not buffer enough to continue.\n");
            return -1;
        }
        size_t len = file.read(buffer, bufferSize);
        done = file.isAtEnd();
        XML_Status status = XML_ParseBuffer(parser, len, done);
        if (XML_STATUS_ERROR == status) {
            XML_Error error = XML_GetErrorCode(parser);
            int line = XML_GetCurrentLineNumber(parser);
            int column = XML_GetCurrentColumnNumber(parser);
            int index = XML_GetCurrentByteIndex(parser);
            const XML_LChar* errorString = XML_ErrorString(error);
            SkDebugf("Line: %d Column: %d (Offset: %d) Error %d: %s.\n",
                          line,    column,      index,    error, errorString);
            return -1;
        }
    }
    return self.fVersion;
}

/** Returns the version of the system font file actually found, negative if none. */
static int append_system_font_families(SkTDArray<FontFamily*>& fontFamilies,
                                       const SkString& basePath)
{
    int initialCount = fontFamilies.count();
    int version = parse_config_file(LMP_SYSTEM_FONTS_FILE, fontFamilies, basePath, false);
    if (version < 0 || fontFamilies.count() == initialCount) {
        version = parse_config_file(OLD_SYSTEM_FONTS_FILE, fontFamilies, basePath, false);
    }
    return version;
}

/**
 * In some versions of Android prior to Android 4.2 (JellyBean MR1 at API
 * Level 17) the fallback fonts for certain locales were encoded in their own
 * XML files with a suffix that identified the locale.  We search the provided
 * directory for those files,add all of their entries to the fallback chain, and
 * include the locale as part of each entry.
 */
static void append_fallback_font_families_for_locale(SkTDArray<FontFamily*>& fallbackFonts,
                                                     const char* dir,
                                                     const SkString& basePath)
{
#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
    // The framework is beyond Android 4.2 and can therefore skip this function
    return;
#endif

    SkAutoTCallIProc<DIR, closedir> fontDirectory(opendir(dir));
    if (NULL == fontDirectory) {
        return;
    }

    for (struct dirent* dirEntry; (dirEntry = readdir(fontDirectory));) {
        // The size of the prefix and suffix.
        static const size_t fixedLen = sizeof(LOCALE_FALLBACK_FONTS_PREFIX) - 1
                                     + sizeof(LOCALE_FALLBACK_FONTS_SUFFIX) - 1;

        // The size of the prefix, suffix, and a minimum valid language code
        static const size_t minSize = fixedLen + 2;

        SkString fileName(dirEntry->d_name);
        if (fileName.size() < minSize ||
            !fileName.startsWith(LOCALE_FALLBACK_FONTS_PREFIX) ||
            !fileName.endsWith(LOCALE_FALLBACK_FONTS_SUFFIX))
        {
            continue;
        }

        SkString locale(fileName.c_str() + sizeof(LOCALE_FALLBACK_FONTS_PREFIX) - 1,
                        fileName.size() - fixedLen);

        SkString absoluteFilename;
        absoluteFilename.printf("%s/%s", dir, fileName.c_str());

        SkTDArray<FontFamily*> langSpecificFonts;
        parse_config_file(absoluteFilename.c_str(), langSpecificFonts, basePath, true);

        for (int i = 0; i < langSpecificFonts.count(); ++i) {
            FontFamily* family = langSpecificFonts[i];
            family->fLanguage = SkLanguage(locale);
            *fallbackFonts.append() = family;
        }
    }
}

static void append_system_fallback_font_families(SkTDArray<FontFamily*>& fallbackFonts,
                                                 const SkString& basePath)
{
    parse_config_file(FALLBACK_FONTS_FILE, fallbackFonts, basePath, true);
    append_fallback_font_families_for_locale(fallbackFonts,
                                             LOCALE_FALLBACK_FONTS_SYSTEM_DIR,
                                             basePath);
}

static void mixin_vendor_fallback_font_families(SkTDArray<FontFamily*>& fallbackFonts,
                                                const SkString& basePath)
{
    SkTDArray<FontFamily*> vendorFonts;
    parse_config_file(VENDOR_FONTS_FILE, vendorFonts, basePath, true);
    append_fallback_font_families_for_locale(vendorFonts,
                                             LOCALE_FALLBACK_FONTS_VENDOR_DIR,
                                             basePath);

    // 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->fOrder;
        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;
        }
    }
}

void SkFontConfigParser::GetSystemFontFamilies(SkTDArray<FontFamily*>& fontFamilies) {
    // Version 21 of the system font configuration does not need any fallback configuration files.
    SkString basePath(getenv("ANDROID_ROOT"));
    basePath.append(SK_FONT_FILE_PREFIX, sizeof(SK_FONT_FILE_PREFIX) - 1);

    if (append_system_font_families(fontFamilies, basePath) >= 21) {
        return;
    }

    // Append all the fallback fonts to system fonts
    SkTDArray<FontFamily*> fallbackFonts;
    append_system_fallback_font_families(fallbackFonts, basePath);
    mixin_vendor_fallback_font_families(fallbackFonts, basePath);
    fontFamilies.append(fallbackFonts.count(), fallbackFonts.begin());
}

void SkFontConfigParser::GetCustomFontFamilies(SkTDArray<FontFamily*>& fontFamilies,
                                               const SkString& basePath,
                                               const char* fontsXml,
                                               const char* fallbackFontsXml,
                                               const char* langFallbackFontsDir)
{
    if (fontsXml) {
        parse_config_file(fontsXml, fontFamilies, basePath, false);
    }
    if (fallbackFontsXml) {
        parse_config_file(fallbackFontsXml, fontFamilies, basePath, true);
    }
    if (langFallbackFontsDir) {
        append_fallback_font_families_for_locale(fontFamilies,
                                                 langFallbackFontsDir,
                                                 basePath);
    }
}

SkLanguage SkLanguage::getParent() const {
    SkASSERT(!fTag.isEmpty());
    const char* tag = fTag.c_str();

    // strip off the rightmost "-.*"
    const char* parentTagEnd = strrchr(tag, '-');
    if (parentTagEnd == NULL) {
        return SkLanguage();
    }
    size_t parentTagLen = parentTagEnd - tag;
    return SkLanguage(tag, parentTagLen);
}