Use test config in SkFontMgr_android.

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 "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
@@ skipping 83 matching lines @@
         *ttcIndex = fIndex;
         return fStream->duplicate();
     }
 
 private:
     SkAutoTUnref<SkStream> fStream;
 
     typedef SkTypeface_Android INHERITED;
 };
 
-void get_path_for_sys_fonts(SkString* full, const SkString& name) {
-    full->set(getenv("ANDROID_ROOT"));
-    full->append(SK_FONT_FILE_PREFIX);
+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) {
+    explicit SkFontStyleSet_Android(const FontFamily& family, const char* basePath) {
         const SkString* cannonicalFamilyName = NULL;
         if (family.fNames.count() > 0) {
             cannonicalFamilyName = &family.fNames[0];
         }
         // TODO? make this lazy
         for (int i = 0; i < family.fFontFiles.count(); ++i) {
             const FontFileInfo& fontFile = family.fFontFiles[i];
 
             SkString pathName;
-            get_path_for_sys_fonts(&pathName, fontFile.fFileName);
+            get_path_for_sys_fonts(basePath, fontFile.fFileName, &pathName);
 
             SkAutoTUnref<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;
             SkTypeface::Style style;
@@ skipping 104 matching lines @@
 struct NameToFamily {
     SkString name;
     SkFontStyleSet_Android* styleSet;
 };
 
 class SkFontMgr_Android : public SkFontMgr {
 public:
     SkFontMgr_Android() {
         SkTDArray<FontFamily*> fontFamilies;
         SkFontConfigParser::GetFontFamilies(fontFamilies);
-        this->buildNameToFamilyMap(fontFamilies);
+        this->buildNameToFamilyMap(fontFamilies, NULL);
+        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();
     }
 
 protected:
     /** Returns not how many families we have, but how many unique names
      *  exist among the families.
      */
     virtual int onCountFamilies() const SK_OVERRIDE {
         return fNameToFamilyMap.count();
     }
@@ skipping 144 matching lines @@
 
 private:
 
     SkTArray<SkAutoTUnref<SkFontStyleSet_Android>, true> fFontStyleSets;
     SkFontStyleSet* fDefaultFamily;
     SkTypeface* fDefaultTypeface;
 
     SkTDArray<NameToFamily> fNameToFamilyMap;
     SkTDArray<NameToFamily> fFallbackNameToFamilyMap;
 
-    void buildNameToFamilyMap(SkTDArray<FontFamily*> families) {
+    void buildNameToFamilyMap(SkTDArray<FontFamily*> families, const char* basePath) {
         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));
+            SkFontStyleSet_Android* newSet = SkNEW_ARGS(SkFontStyleSet_Android, (family, basePath));
             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 25 matching lines @@
         SkASSERT(fDefaultFamily);
         SkASSERT(fDefaultTypeface);
     }
 
     typedef SkFontMgr INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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* basePath;
+    SkGetTestFontConfiguration(&mainConfigFile, &fallbackConfigFile, &basePath);
+    if (mainConfigFile) {
+        SkNEW_ARGS(SkFontMgr_Android, (mainConfigFile, fallbackConfigFile, basePath));

[bungeman-skia, 2014/08/11 17:45:23]

Need to return here.

+    }
+
     return SkNEW(SkFontMgr_Android);
 }