Rename SkFontConfigParser_android SkFontMgr_android_parser.

src/ports/SkFontMgr_android_parser.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 "SkFontMgr_android_parser.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
 #include "SkTypeface.h"
 
 #include <expat.h>
 #include <dirent.h>
 
 #include <stdlib.h>
 
@@ skipping 89 matching lines @@
     SkTDArray<const TagHandler*> fHandler;    // The stack of current tag handlers.
 };
 
 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)
 
-#define SK_FONTCONFIGPARSER_PREFIX "[SkFontConfigParser] "
+#define SK_FONTMGR_ANDROID_PARSER_PREFIX "[SkFontMgr Android Parser] "
 
 #define SK_FONTCONFIGPARSER_WARNING(message, ...) SkDebugf( \
-    SK_FONTCONFIGPARSER_PREFIX "%s:%d:%d: warning: " message "\n", \
+    SK_FONTMGR_ANDROID_PARSER_PREFIX "%s:%d:%d: warning: " message "\n", \
     self->fFilename, \
     XML_GetCurrentLineNumber(self->fParser), \
     XML_GetCurrentColumnNumber(self->fParser), \
     ##__VA_ARGS__);
 
 static bool is_whitespace(char c) {
     return c == ' ' || c == '\n'|| c == '\r' || c == '\t';
 }
 
 static void trim_string(SkString* s) {
@@ skipping 452 matching lines @@
  * 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(SK_FONTCONFIGPARSER_PREFIX "'%s' could not be opened\n", filename);
+        SkDebugf(SK_FONTMGR_ANDROID_PARSER_PREFIX "'%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(SK_FONTCONFIGPARSER_PREFIX "could not create XML parser\n");
+        SkDebugf(SK_FONTMGR_ANDROID_PARSER_PREFIX "could not create XML parser\n");
         return -1;
     }
 
     FamilyData self(parser, families, basePath, isFallback, filename, &topLevelHandler);
     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, start_element_handler, 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(SK_FONTCONFIGPARSER_PREFIX "could not buffer enough to continue\n");
+            SkDebugf(SK_FONTMGR_ANDROID_PARSER_PREFIX "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);
             const XML_LChar* errorString = XML_ErrorString(error);
-            SkDebugf(SK_FONTCONFIGPARSER_PREFIX "%s:%d:%d error %d: %s.\n",
+            SkDebugf(SK_FONTMGR_ANDROID_PARSER_PREFIX "%s:%d:%d error %d: %s.\n",
                      filename, line, column, 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)
@@ skipping 95 matching lines @@
             }
         } 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) {
+void SkFontMgr_Android_Parser::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)
+void SkFontMgr_Android_Parser::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);
 }