Regularize lmp::XXX_element_handler.

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 108 matching lines @@
 
 #define SK_FONTCONFIGPARSER_WARNING(message, ...) SkDebugf( \
     SK_FONTCONFIGPARSER_PREFIX "%s:%d:%d: warning: " message "\n", \
     self->fFilename, \
     XML_GetCurrentLineNumber(self->fParser), \
     XML_GetCurrentColumnNumber(self->fParser), \
     ##__VA_ARGS__);
 
 namespace lmpParser {
 
-static void family_element_handler(FontFamily* family, const char** attributes) {
+static void family_element_handler(FamilyData* self, const char** attributes) {
     // A <family> element without a 'name' (string) attribute is a fallback font.
     // The element may have 'lang' (string) and 'variant' ("elegant", "compact") attributes.
     // The element should contain <font> elements.
-    family->fIsFallbackFont = true;
+    FontFamily* family = new FontFamily(self->fBasePath, true);
+    self->fCurrentFamily.reset(family);
     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)) {
             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) {
+static void font_element_handler(FamilyData* self, const char** attributes) {
     // A <font> element should be contained in a <family> element.
     // The element may have 'weight' (non-negative integer), 'style' ("normal", "italic"),
     // and 'index' (non-negative integer) attributes.
     // The element should contain a filename.
+    FontFileInfo& file = self->fCurrentFamily->fFonts.push_back();
+    self->fCurrentFontInfo = &file;
     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)) {
+            if (!parse_non_negative_integer(value, &file.fWeight)) {
                 SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid weight", value);
             }
         } else if (MEMEQ("style", name, nameLen)) {
             size_t valueLen = strlen(value);
             if (MEMEQ("normal", value, valueLen)) {
-                file->fStyle = FontFileInfo::Style::kNormal;
+                file.fStyle = FontFileInfo::Style::kNormal;
             } else if (MEMEQ("italic", value, valueLen)) {
-                file->fStyle = FontFileInfo::Style::kItalic;
+                file.fStyle = FontFileInfo::Style::kItalic;
             }
         } else if (MEMEQ("index", name, nameLen)) {
-            if (!parse_non_negative_integer(value, &file->fIndex)) {
+            if (!parse_non_negative_integer(value, &file.fIndex)) {
                 SK_FONTCONFIGPARSER_WARNING("'%s' is an invalid index", 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];
@@ skipping 53 matching lines @@
         *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);
+        family_element_handler(self, attributes);
     } else if (MEMEQ("font", tag, len)) {
-        FontFileInfo* file = &self->fCurrentFamily->fFonts.push_back();
-        self->fCurrentFontInfo = file;
-        font_element_handler(self, file, attributes);
+        font_element_handler(self, 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();
@@ skipping 379 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);
 }