Revert of Extend SkFontMgr_Custom to cover ttc, otf, pfb.

src/ports/SkFontHost_linux.cpp

 /*
  * Copyright 2006 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 "SkFontHost.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkFontDescriptor.h"
 #include "SkFontMgr.h"
 #include "SkDescriptor.h"
 #include "SkOSFile.h"
 #include "SkPaint.h"
 #include "SkString.h"
 #include "SkStream.h"
 #include "SkThread.h"
 #include "SkTSearch.h"
 #include "SkTypefaceCache.h"
 #include "SkTArray.h"
 
 #include <limits>
 
 #ifndef SK_FONT_FILE_PREFIX
-#    define SK_FONT_FILE_PREFIX "/usr/share/fonts/"
+#    define SK_FONT_FILE_PREFIX "/usr/share/fonts/truetype/"
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /** The base SkTypeface implementation for the custom font manager. */
 class SkTypeface_Custom : public SkTypeface_FreeType {
 public:
     SkTypeface_Custom(const SkFontStyle& style, bool isFixedPitch,
                       bool sysFont, const SkString familyName, int index)
         : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
@@ skipping 232 matching lines @@
 
     virtual SkTypeface* onCreateFromStream(SkStream* stream, int ttcIndex) const SK_OVERRIDE {
         if (NULL == stream || stream->getLength() <= 0) {
             SkDELETE(stream);
             return NULL;
         }
 
         bool isFixedPitch;
         SkFontStyle style;
         SkString name;
-        if (fScanner.scanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
+        if (SkTypeface_FreeType::ScanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
             return SkNEW_ARGS(SkTypeface_Stream, (style, isFixedPitch, false, name,
                                                   stream, ttcIndex));
         } else {
             return NULL;
         }
     }
 
     virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
         return stream.get() ? this->createFromStream(stream, ttcIndex) : NULL;
@@ skipping 18 matching lines @@
 
         if (NULL == tf) {
             tf = gDefaultFamily->matchStyle(style);
         }
 
         return SkSafeRef(tf);
     }
 
 private:
 
-    void load_directory_fonts(const SkString& directory, const char* suffix) {
-        SkOSFile::Iter iter(directory.c_str(), suffix);
+    static bool get_name_and_style(const char path[], SkString* name,
+                                   SkFontStyle* style, bool* isFixedPitch) {
+        SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
+        if (stream.get()) {
+            return SkTypeface_FreeType::ScanFont(stream, 0, name, style, isFixedPitch);
+        } else {
+            SkDebugf("---- failed to open <%s> as a font\n", path);
+            return false;
+        }
+    }
+
+    void load_directory_fonts(const SkString& directory) {
+        SkOSFile::Iter iter(directory.c_str(), ".ttf");
         SkString name;
 
         while (iter.next(&name, false)) {
-            SkString filename(SkOSPath::Join(directory.c_str(), name.c_str()));
-            SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(filename.c_str()));
-            if (!stream.get()) {
-                SkDebugf("---- failed to open <%s>\n", filename.c_str());
+            SkString filename(
+                SkOSPath::Join(directory.c_str(), name.c_str()));
+
+            bool isFixedPitch;
+            SkString realname;
+            SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
+            if (!get_name_and_style(filename.c_str(), &realname, &style, &isFixedPitch)) {
+                SkDebugf("------ can't load <%s> as a font\n", filename.c_str());
                 continue;
             }
 
-            int numFaces;
-            if (!fScanner.recognizedFont(stream, &numFaces)) {
-                SkDebugf("---- failed to open <%s> as a font\n", filename.c_str());
-                continue;
+            SkTypeface_Custom* tf = SkNEW_ARGS(SkTypeface_File, (
+                                                style,
+                                                isFixedPitch,
+                                                true,  // system-font (cannot delete)
+                                                realname,
+                                                filename.c_str(), 0));
+
+            SkFontStyleSet_Custom* addTo = this->onMatchFamily(realname.c_str());
+            if (NULL == addTo) {
+                addTo = new SkFontStyleSet_Custom(realname);
+                fFamilies.push_back().reset(addTo);
             }
-
-            for (int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
-                bool isFixedPitch;
-                SkString realname;
-                SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
-                if (!fScanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch)) {
-                    SkDebugf("---- failed to open <%s> <%d> as a font\n",
-                             filename.c_str(), faceIndex);
-                    continue;
-                }
-
-                SkTypeface_Custom* tf = SkNEW_ARGS(SkTypeface_File, (
-                                                    style,
-                                                    isFixedPitch,
-                                                    true,  // system-font (cannot delete)
-                                                    realname,
-                                                    filename.c_str(), 0));
-
-                SkFontStyleSet_Custom* addTo = this->onMatchFamily(realname.c_str());
-                if (NULL == addTo) {
-                    addTo = new SkFontStyleSet_Custom(realname);
-                    fFamilies.push_back().reset(addTo);
-                }
-                addTo->appendTypeface(tf);
-            }
+            addTo->appendTypeface(tf);
         }
 
         SkOSFile::Iter dirIter(directory.c_str());
         while (dirIter.next(&name, true)) {
             if (name.startsWith(".")) {
                 continue;
             }
             SkString dirname(SkOSPath::Join(directory.c_str(), name.c_str()));
-            load_directory_fonts(dirname, suffix);
+            load_directory_fonts(dirname);
         }
     }
 
     void load_system_fonts(const char* dir) {
         SkString baseDirectory(dir);
-        load_directory_fonts(baseDirectory, ".ttf");
-        load_directory_fonts(baseDirectory, ".ttc");
-        load_directory_fonts(baseDirectory, ".otf");
-        load_directory_fonts(baseDirectory, ".pfb");
+        load_directory_fonts(baseDirectory);
 
         if (fFamilies.empty()) {
             SkFontStyleSet_Custom* family = new SkFontStyleSet_Custom(SkString());
             fFamilies.push_back().reset(family);
             family->appendTypeface(SkNEW(SkTypeface_Empty));
         }
 
         // Try to pick a default font.
         static const char* gDefaultNames[] = {
             "Arial", "Verdana", "Times New Roman", "Droid Sans", NULL
@@ skipping 17 matching lines @@
         }
         if (NULL == gDefaultNormal) {
             gDefaultFamily = fFamilies[0];
             gDefaultNormal = gDefaultFamily->fStyles[0];
         }
     }
 
     SkTArray<SkAutoTUnref<SkFontStyleSet_Custom>, true> fFamilies;
     SkFontStyleSet_Custom* gDefaultFamily;
     SkTypeface* gDefaultNormal;
-    SkTypeface_FreeType::Scanner fScanner;
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return new SkFontMgr_Custom(SK_FONT_FILE_PREFIX);
 }