Additional cleanups to Android config parsing.

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"
@@ skipping 97 matching lines @@
 
 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 {
 
-void familyElementHandler(FontFamily* family, const char** attributes) {
+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;
             }
         }
     }
 }
 
-void XMLCALL fontFileNameHandler(void* data, const char* s, int len) {
+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);
 }
 
-void fontElementHandler(FamilyData* self, FontFileInfo* file, const char** attributes) {
+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, fontFileNameHandler);
+    XML_SetCharacterDataHandler(self->fParser, font_file_name_handler);
 }
 
-FontFamily* findFamily(FamilyData* self, const SkString& familyName) {
+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;
 }
 
-void aliasElementHandler(FamilyData* self, const char** attributes) {
+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 = findFamily(self, to);
+    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);
     }
 }
 
-void XMLCALL startElementHandler(void* data, const char* tag, const char** attributes) {
+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));
-        familyElementHandler(self->fCurrentFamily, attributes);
+        family_element_handler(self->fCurrentFamily, attributes);
     } else if (MEMEQ("font", tag, len)) {
         FontFileInfo* file = &self->fCurrentFamily->fFonts.push_back();
         self->fCurrentFontInfo = file;
-        fontElementHandler(self, file, attributes);
+        font_element_handler(self, file, attributes);
     } else if (MEMEQ("alias", tag, len)) {
-        aliasElementHandler(self, attributes);
+        alias_element_handler(self, attributes);
     }
 }
 
-void XMLCALL endElementHandler(void* data, const char* tag) {
+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
@@ skipping 77 matching lines @@
     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::startElementHandler,
-                                      lmpParser::endElementHandler);
+                                      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;
@@ skipping 46 matching lines @@
                                             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(NULL));
+    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);
 
-    char buffer[512];
+    // 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.)
+    static const int bufferSize = 512;
     bool done = false;
     while (!done) {
-        size_t len = file.read(buffer, SK_ARRAY_COUNT(buffer));
+        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_Parse(parser, buffer, len, done);
+        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;
         }
@@ skipping 146 matching lines @@
     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);
 }