Do not add indirection to XML_Parser.

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 33 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) :
+    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
+    XML_Parser parser;                 // The expat parser doing the work, owned by caller
+    SkTDArray<FontFamily*>& families;  // The array to append families, owned by caller
+    FontFamily* currentFamily;         // The current family being created, owned by this
+    FontFileInfo* currentFontInfo;     // The current fontInfo being created, owned by currentFamily
     int currentTag;                    // A flag to indicate whether we're in nameset/fileset tags
 };
 
 /** http://www.w3.org/TR/html-markup/datatypes.html#common.data.integer.non-negative-def */
 template <typename T> static bool parseNonNegativeInteger(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) {
@@ skipping 40 matching lines @@
             }
         }
     }
 }
 
 void fontFileNameHandler(void* data, const char* s, int len) {
     FamilyData* familyData = (FamilyData*) data;
     familyData->currentFontInfo->fFileName.set(s, len);
 }
 
-void fontElementHandler(XML_Parser* parser, FontFileInfo* file, const char** attributes) {
+void fontElementHandler(XML_Parser parser, 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; attributes[i] != NULL &&
                        attributes[i+1] != NULL; i += 2) {
         const char* name = attributes[i];
         const char* value = attributes[i+1];
         size_t nameLen = strlen(name);
         if (nameLen == 6 && !strncmp("weight", name, nameLen)) {
             if (!parseNonNegativeInteger(value, &file->fWeight)) {
                 SkDebugf("---- Font weight %s (INVALID)", value);
                 file->fWeight = 0;
             }
         }
     }
-    XML_SetCharacterDataHandler(*parser, fontFileNameHandler);
+    XML_SetCharacterDataHandler(parser, fontFileNameHandler);
 }
 
 FontFamily* findFamily(FamilyData* familyData, const char* familyName) {
     size_t nameLen = strlen(familyName);
     for (int i = 0; i < familyData->families.count(); i++) {
         FontFamily* candidate = familyData->families[i];
         for (int j = 0; j < candidate->fNames.count(); j++) {
             if (!strncmp(candidate->fNames[j].c_str(), familyName, nameLen) &&
                 nameLen == strlen(candidate->fNames[j].c_str())) {
                 return candidate;
@@ skipping 66 matching lines @@
     }
 }
 
 void endElementHandler(void* data, const char* tag) {
     FamilyData* familyData = (FamilyData*) data;
     size_t len = strlen(tag);
     if (len == 6 && strncmp(tag, "family", len) == 0) {
         *familyData->families.append() = familyData->currentFamily;
         familyData->currentFamily = NULL;
     } else if (len == 4 && !strncmp(tag, "font", len)) {
-        XML_SetCharacterDataHandler(*familyData->parser, NULL);
+        XML_SetCharacterDataHandler(familyData->parser, 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.
@@ skipping 63 matching lines @@
                     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;
-    XML_SetCharacterDataHandler(*familyData->parser, textHandler);
+    XML_SetCharacterDataHandler(familyData->parser, textHandler);
 }
 
 /**
  * Handler for the start of a tag. The only tags we expect are familyset, family,
  * nameset, fileset, name, and file.
  */
 static void startElementHandler(void* data, const char* tag, const char** atts) {
     FamilyData* familyData = (FamilyData*) data;
     size_t len = strlen(tag);
     if (len == 9 && strncmp(tag, "familyset", len) == 0) {
         // The familyset tag has an optional "version" attribute with an integer value >= 0
         for (size_t i = 0; atts[i] != NULL &&
                            atts[i+1] != NULL; i += 2) {
             size_t nameLen = strlen(atts[i]);
             if (nameLen == 7 && strncmp(atts[i], "version", nameLen)) continue;
             const char* valueString = atts[i+1];
             int version;
             if (parseNonNegativeInteger(valueString, &version) && (version >= 21)) {
-                XML_SetElementHandler(*familyData->parser,
+                XML_SetElementHandler(familyData->parser,
                                       lmpParser::startElementHandler,
                                       lmpParser::endElementHandler);
             }
         }
     } else if (len == 6 && strncmp(tag, "family", len) == 0) {
         familyData->currentFamily = new FontFamily();
         // 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[i] != NULL &&
                            atts[i+1] != NULL; i += 2) {
             const char* valueString = atts[i+1];
             int value;
             if (parseNonNegativeInteger(valueString, &value)) {
                 familyData->currentFamily->fOrder = 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 (len == 4 && strncmp(tag, "name", len) == 0 && familyData->currentTag == NAMESET_TAG) {
         // If it's a Name, parse the text inside
-        XML_SetCharacterDataHandler(*familyData->parser, textHandler);
+        XML_SetCharacterDataHandler(familyData->parser, textHandler);
     } else if (len == 4 && 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;
     size_t len = strlen(tag);
     if (len == 6 && 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 ((len == 4 &&
                 strncmp(tag, "name", len) == 0 &&
                 familyData->currentTag == NAMESET_TAG) ||
                (len == 4 &&
                 strncmp(tag, "file", len) == 0 &&
                 familyData->currentTag == FILESET_TAG)) {
         // Disable the arbitrary text handler installed to load Name data
-        XML_SetCharacterDataHandler(*familyData->parser, NULL);
+        XML_SetCharacterDataHandler(familyData->parser, NULL);
     }
 }
 
 } // namespace jbParser
 
 /**
  * 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 = 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);
     XML_SetUserData(parser, familyData);
     // Start parsing oldschool; switch these in flight if we detect a newer version of the file.
     XML_SetElementHandler(parser, jbParser::startElementHandler, jbParser::endElementHandler);
 
     char buffer[512];
     bool done = false;
     while (!done) {
         fgets(buffer, sizeof(buffer), file);
         size_t len = strlen(buffer);
         if (feof(file) != 0) {
@@ skipping 139 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);
 }