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 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 {
 
-static void family_element_handler(FontFamily* family, const char** attributes) {
+static void family_element_handler(FamilyData* self, 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;
+    FontFamily& family = *self->fCurrentFamily;
+    family.fIsFallbackFont = true;

[tomhudson, 2015/04/20 18:11:39]

Why are you making /family/ a reference instead of a pointer?

[bungeman-skia, 2015/04/20 20:14:57]

Mostly for consistency with font_element_handler, though it turns out the real
reason for that inconsistency is that one gets held in a SkTArray and other in
an SkTDArray, which is something which should also be fixed. I took a look into
fixing that, but that's another CL. I'll just leave this a pointer for no then.

     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;
+            family.fNames.push_back().set(tolc.lc());
+            family.fIsFallbackFont = false;
         } else if (MEMEQ("lang", name, nameLen)) {
-            family->fLanguage = SkLanguage(value, valueLen);
+            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;
+                family.fVariant = kElegant_FontVariant;
             } else if (MEMEQ("compact", value, valueLen)) {
-                family->fVariant = kCompact_FontVariant;
+                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> should have weight (integer) and style (normal, italic) attributes.
     // NOTE: we ignore the style.
     // The element should contain a filename.
+    FontFileInfo& file = *self->fCurrentFontInfo;
     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)) {
                 SkDebugf("---- Font weight %s (INVALID)", 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)) {
                 SkDebugf("---- Font index %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];
@@ skipping 52 matching lines @@
     } 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);
+        self->fCurrentFontInfo = &self->fCurrentFamily->fFonts.push_back();
+        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 376 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);
 }