Add factory for Android font manager.

src/ports/SkFontMgr_android.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * 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 "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkFontMgr.h"
+#include "SkFontMgr_android.h"
 #include "SkFontStyle.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
 #include "SkTypeface.h"
 #include "SkTypeface_android.h"
 #include "SkTypefaceCache.h"
 
 #include <limits>
-#include <stdlib.h>
-
-#ifndef SK_FONT_FILE_PREFIX
-#    define SK_FONT_FILE_PREFIX "/fonts/"
-#endif
 
 #ifndef SK_DEBUG_FONTS
     #define SK_DEBUG_FONTS 0
 #endif
 
 #if SK_DEBUG_FONTS
 #    define DEBUG_FONT(args) SkDebugf args
 #else
 #    define DEBUG_FONT(args)
 #endif
@@ skipping 83 matching lines @@
         *ttcIndex = fIndex;
         return fStream->duplicate();
     }
 
 private:
     SkAutoTDelete<SkStreamAsset> fStream;
 
     typedef SkTypeface_Android INHERITED;
 };
 
-void get_path_for_sys_fonts(const char* basePath, const SkString& name, SkString* full) {
-    if (basePath) {
-        full->set(basePath);
-    } else {
-        full->set(getenv("ANDROID_ROOT"));
-        full->append(SK_FONT_FILE_PREFIX);
-    }
-    full->append(name);
-}
-
 class SkFontStyleSet_Android : public SkFontStyleSet {
 public:
-    explicit SkFontStyleSet_Android(const FontFamily& family, const char* basePath,
+    explicit SkFontStyleSet_Android(const FontFamily& family,
                                     const SkTypeface_FreeType::Scanner& scanner)
     {
         const SkString* cannonicalFamilyName = NULL;
         if (family.fNames.count() > 0) {
             cannonicalFamilyName = &family.fNames[0];
         }
         // TODO? make this lazy
         for (int i = 0; i < family.fFonts.count(); ++i) {
             const FontFileInfo& fontFile = family.fFonts[i];
 
-            SkString pathName;
-            get_path_for_sys_fonts(basePath, fontFile.fFileName, &pathName);
+            SkString pathName(family.fBasePath);
+            pathName.append(fontFile.fFileName);
 
             SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
             if (!stream.get()) {
                 DEBUG_FONT(("---- SystemFonts[%d] file=%s (NOT EXIST)", i, pathName.c_str()));
                 continue;
             }
 
             const int ttcIndex = fontFile.fIndex;
             SkString familyName;
             SkFontStyle style;
@@ skipping 94 matching lines @@
  *  (non-replicated) set of typefaces.
  *  SkTDict<> doesn't let us do index-based lookup, so we write our own mapping.
  */
 struct NameToFamily {
     SkString name;
     SkFontStyleSet_Android* styleSet;
 };
 
 class SkFontMgr_Android : public SkFontMgr {
 public:
-    SkFontMgr_Android() {
-        SkTDArray<FontFamily*> fontFamilies;
-        SkFontConfigParser::GetFontFamilies(fontFamilies);
-        this->buildNameToFamilyMap(fontFamilies, NULL);
+    SkFontMgr_Android(const SkFontMgr_Android_CustomFonts* custom) {
+        SkTDArray<FontFamily*> families;
+        if (custom && SkFontMgr_Android_CustomFonts::kPreferSystem != custom->fSystemFontUse) {
+            SkString base(custom->fBasePath);
+            SkFontConfigParser::GetCustomFontFamilies(families, base,
+                                                      custom->fFontsXml, custom->fFallbackFontsXml);
+        }
+        if (!custom ||
+            (custom && SkFontMgr_Android_CustomFonts::kOnlyCustom != custom->fSystemFontUse))
+        {
+            SkFontConfigParser::GetSystemFontFamilies(families);
+        }
+        if (custom && SkFontMgr_Android_CustomFonts::kPreferSystem == custom->fSystemFontUse) {
+            SkString base(custom->fBasePath);
+            SkFontConfigParser::GetCustomFontFamilies(families, base,
+                                                      custom->fFontsXml, custom->fFallbackFontsXml);
+        }
+        this->buildNameToFamilyMap(families);
         this->findDefaultFont();
-    }
-    SkFontMgr_Android(const char* mainConfigFile, const char* fallbackConfigFile,
-                      const char* basePath)
-    {
-        SkTDArray<FontFamily*> fontFamilies;
-        SkFontConfigParser::GetTestFontFamilies(fontFamilies, mainConfigFile, fallbackConfigFile);
-        this->buildNameToFamilyMap(fontFamilies, basePath);
-        this->findDefaultFont();
+        families.deleteAll();
     }
 
 protected:
     /** Returns not how many families we have, but how many unique names
      *  exist among the families.
      */
     int onCountFamilies() const SK_OVERRIDE {
         return fNameToFamilyMap.count();
     }
 
@@ skipping 158 matching lines @@
 
     SkTypeface_FreeType::Scanner fScanner;
 
     SkTArray<SkAutoTUnref<SkFontStyleSet_Android>, true> fFontStyleSets;
     SkFontStyleSet* fDefaultFamily;
     SkTypeface* fDefaultTypeface;
 
     SkTDArray<NameToFamily> fNameToFamilyMap;
     SkTDArray<NameToFamily> fFallbackNameToFamilyMap;
 
-    void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const char* basePath) {
+    void buildNameToFamilyMap(SkTDArray<FontFamily*> families) {
         for (int i = 0; i < families.count(); i++) {
             FontFamily& family = *families[i];
 
             SkTDArray<NameToFamily>* nameToFamily = &fNameToFamilyMap;
             if (family.fIsFallbackFont) {
                 nameToFamily = &fFallbackNameToFamilyMap;
 
                 if (0 == family.fNames.count()) {
                     SkString& fallbackName = family.fNames.push_back();
                     fallbackName.printf("%.2x##fallback", i);
                 }
             }
 
             SkFontStyleSet_Android* newSet =
-                SkNEW_ARGS(SkFontStyleSet_Android, (family, basePath, fScanner));
+                SkNEW_ARGS(SkFontStyleSet_Android, (family, fScanner));
             if (0 == newSet->count()) {
                 SkDELETE(newSet);
                 continue;
             }
             fFontStyleSets.push_back().reset(newSet);
 
             for (int j = 0; j < family.fNames.count(); j++) {
                 NameToFamily* nextEntry = nameToFamily->append();
                 SkNEW_PLACEMENT_ARGS(&nextEntry->name, SkString, (family.fNames[j]));
                 nextEntry->styleSet = newSet;
@@ skipping 24 matching lines @@
         }
         SkASSERT(fDefaultFamily);
         SkASSERT(fDefaultTypeface);
     }
 
     typedef SkFontMgr INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
+SkFontMgr* SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom) {
+#define COMMA ,

[djsollen, 2015/02/04 23:11:06]

what is the point of this define?  Just use a comma.

[bungeman-skia, 2015/02/04 23:32:11]

SkDEBUGCODE is a macro, so any literal comma is seen as an argument separator. I
just want an array of strings whenever SkASSERT isn't def'ed away. I'll see if
there's any nicer looking way to do this, I suppose I could just use SK_DEBUG,
it seems nice to avoid directly using it.

[bungeman-skia, 2015/02/04 23:48:50]

Done.

+    SkDEBUGCODE(static char const * const SystemFontUseStrings[] = {
+        "OnlyCustom" COMMA "PreferCustom" COMMA "PreferSystem"
+    };)
+#undef COMMA
+    if (custom) {
+        SkASSERT(0 <= custom->fSystemFontUse);
+        SkASSERT(     custom->fSystemFontUse < SK_ARRAY_COUNT(SystemFontUseStrings));

[djsollen, 2015/02/04 23:11:07]

nit: fix spacing

[bungeman-skia, 2015/02/04 23:32:11]

I'm just trying to show very obviously that I'm testing that the value is
between two other values. It would be nice if one could write

SkASSERT(0 <= custom->fSystemFontUse < SK_ARRAY_COUNT(SystemFontUseStrings));

and have it do the right thing. Maybe we have an 'inrange' somewhere for this?
I'd write it all on one line, but I think it's a little long then.

[bungeman-skia, 2015/02/04 23:48:50]

Done.

+        SkDEBUGF(("SystemFontUse: %s BasePath: %s Fonts: %s FallbackFonts: %s",
+                  SystemFontUseStrings[custom->fSystemFontUse],
+                  custom->fBasePath,
+                  custom->fFontsXml,
+                  custom->fFallbackFontsXml));
+    }
+
+    return SkNEW_ARGS(SkFontMgr_Android, (custom));
+}
+
 SkFontMgr* SkFontMgr::Factory() {
     // The call to SkGetTestFontConfiguration is so that Chromium can override the environment.
     // TODO: these globals need to be removed, in favor of a constructor / separate Factory
     // which can be used instead.
-    const char* mainConfigFile;
-    const char* fallbackConfigFile;
+    const char* fontsXml;
+    const char* fallbackFontsXml;
     const char* basePath;
-    SkGetTestFontConfiguration(&mainConfigFile, &fallbackConfigFile, &basePath);
-    if (mainConfigFile) {
-        return SkNEW_ARGS(SkFontMgr_Android, (mainConfigFile, fallbackConfigFile, basePath));
+    SkGetTestFontConfiguration(&fontsXml, &fallbackFontsXml, &basePath);
+    if ((fontsXml || fallbackFontsXml) && basePath) {
+        SkFontMgr_Android_CustomFonts custom = {
+            SkFontMgr_Android_CustomFonts::kOnlyCustom, basePath, fontsXml, fallbackFontsXml
+        };
+        return SkFontMgr_New_Android(&custom);
     }
 
-    return SkNEW(SkFontMgr_Android);
+    return SkFontMgr_New_Android(NULL);
 }
 
 void SkUseTestFontConfigFile(const char* mainconf, const char* fallbackconf,
                              const char* fontsdir) {
     gTestMainConfigFile = mainconf;
     gTestFallbackConfigFile = fallbackconf;
     gTestFontFilePrefix = fontsdir;
     SkASSERT(gTestMainConfigFile);
     SkASSERT(gTestFallbackConfigFile);
     SkASSERT(gTestFontFilePrefix);
     SkDEBUGF(("Use Test Config File Main %s, Fallback %s, Font Dir %s",
               gTestMainConfigFile, gTestFallbackConfigFile, gTestFontFilePrefix));
 }
 
 void SkGetTestFontConfiguration(const char** mainconf, const char** fallbackconf,
                                 const char** fontsdir) {
     *mainconf = gTestMainConfigFile;
     *fallbackconf = gTestFallbackConfigFile;
     *fontsdir = gTestFontFilePrefix;
 }