Revert of SkFontMgr for Android.

src/ports/SkFontMgr_android.cpp

Index: src/ports/SkFontMgr_android.cpp
diff --git a/src/ports/SkFontMgr_android.cpp b/src/ports/SkFontMgr_android.cpp
deleted file mode 100644
index bce32d88df37b7f734bf503ef274004c933ed32d..0000000000000000000000000000000000000000
--- a/src/ports/SkFontMgr_android.cpp
+++ /dev/null
@@ -1,409 +0,0 @@
-/*
- * 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 "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
-
-class SkTypeface_Android : public SkTypeface_FreeType {
-public:
-    SkTypeface_Android(int index,
-                       Style style,
-                       bool isFixedPitch,
-                       const SkString familyName)
-        : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
-        , fIndex(index)
-        , fFamilyName(familyName)
-    { }
-
-    const SkString& name() const { return fFamilyName; }
-
-protected:
-    int fIndex;
-    SkString fFamilyName;
-
-private:
-    typedef SkTypeface_FreeType INHERITED;
-};
-
-class SkTypeface_AndroidSystem : public SkTypeface_Android {
-public:
-    SkTypeface_AndroidSystem(const SkString pathName,
-                             int index,
-                             Style style,
-                             bool isFixedPitch,
-                             const SkString familyName)
-        : INHERITED(index, style, isFixedPitch, familyName)
-        , fPathName(pathName)
-    { }
-
-    virtual void onGetFontDescriptor(SkFontDescriptor* desc,
-                                     bool* serialize) const SK_OVERRIDE
-    {
-        SkASSERT(desc);
-        SkASSERT(serialize);
-        desc->setFamilyName(fFamilyName.c_str());
-        desc->setFontFileName(fPathName.c_str());
-        *serialize = false;
-    }
-    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
-        *ttcIndex = fIndex;
-        return SkStream::NewFromFile(fPathName.c_str());
-    }
-
-private:
-    SkString fPathName;
-
-    typedef SkTypeface_Android INHERITED;
-};
-
-class SkTypeface_AndroidStream : public SkTypeface_Android {
-public:
-    SkTypeface_AndroidStream(SkStream* stream,
-                             int index,
-                             Style style,
-                             bool isFixedPitch,
-                             const SkString familyName)
-        : INHERITED(index, style, isFixedPitch, familyName)
-        , fStream(stream)
-    { }
-
-    virtual void onGetFontDescriptor(SkFontDescriptor* desc,
-                                     bool* serialize) const SK_OVERRIDE {
-        SkASSERT(desc);
-        SkASSERT(serialize);
-        desc->setFamilyName(fFamilyName.c_str());
-        desc->setFontFileName(NULL);
-        *serialize = true;
-    }
-
-    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
-        *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);
-    full->append(name);
-}
-
-class SkFontStyleSet_Android : public SkFontStyleSet {
-public:
-    explicit SkFontStyleSet_Android(FontFamily* family) : fFontFamily(family) {
-        // TODO? make this lazy
-        for (int i = 0; i < family->fFontFiles.count(); ++i) {
-            const SkString& fileName = family->fFontFiles[i].fFileName;
-
-            SkString pathName;
-            get_path_for_sys_fonts(&pathName, fileName);
-
-            SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
-            if (!stream.get()) {
-                DEBUG_FONT(("---- SystemFonts[%d] file=%s (NOT EXIST)", i, filename.c_str()));
-                continue;
-            }
-
-            SkString fontName;
-            SkTypeface::Style style;
-            bool isFixedWidth;
-            if (!SkTypeface_FreeType::ScanFont(stream.get(), family->fFontFiles[i].fIndex,
-                                               &fontName, &style, &isFixedWidth))
-            {
-                DEBUG_FONT(("---- SystemFonts[%d] file=%s (INVALID)", i, filename.c_str()));
-                continue;
-            }
-
-            fStyles.push_back().reset(SkNEW_ARGS(SkTypeface_AndroidSystem,
-                                                 (pathName, 0,
-                                                  style, isFixedWidth, fontName)));
-        }
-    }
-
-    virtual int count() SK_OVERRIDE {
-        return fStyles.count();
-    }
-    virtual void getStyle(int index, SkFontStyle* style, SkString* name) SK_OVERRIDE {
-        if (index < 0 || fStyles.count() <= index) {
-            return;
-        }
-        if (style) {
-            *style = this->style(index);
-        }
-        if (name) {
-            name->reset();
-        }
-    }
-    virtual SkTypeface* createTypeface(int index) SK_OVERRIDE {
-        if (index < 0 || fStyles.count() <= index) {
-            return NULL;
-        }
-        return SkRef(fStyles[index].get());
-    }
-
-    /** Find the typeface in this style set that most closely matches the given pattern.
-     *  TODO: consider replacing with SkStyleSet_Indirect::matchStyle();
-     *  this simpler version using match_score() passes all our tests.
-     */
-    virtual SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE {
-        if (0 == fStyles.count()) {
-            return NULL;
-        }
-        SkTypeface* closest = fStyles[0];
-        int minScore = std::numeric_limits<int>::max();
-        for (int i = 0; i < fStyles.count(); ++i) {
-            SkFontStyle style = this->style(i);
-            int score = match_score(pattern, style);
-            if (score < minScore) {
-                closest = fStyles[i];
-                minScore = score;
-            }
-        }
-        return SkRef(closest);
-    }
-
-private:
-    SkFontStyle style(int index) {
-        return SkFontStyle(this->weight(index), SkFontStyle::kNormal_Width,
-                           this->slant(index));
-    }
-    SkFontStyle::Weight weight(int index) {
-        if (fStyles[index]->isBold()) return SkFontStyle::kBold_Weight;
-        return SkFontStyle::kNormal_Weight;
-    }
-    SkFontStyle::Slant slant(int index) {
-        if (fStyles[index]->isItalic()) return SkFontStyle::kItalic_Slant;
-        return SkFontStyle::kUpright_Slant;
-    }
-    static int match_score(const SkFontStyle& pattern, const SkFontStyle& candidate) {
-        int score = 0;
-        score += abs((pattern.width() - candidate.width()) * 100);
-        score += abs((pattern.isItalic() == candidate.isItalic()) ? 0 : 1000);
-        score += abs(pattern.weight() - candidate.weight());
-        return score;
-    }
-
-
-    FontFamily* fFontFamily;
-    SkTArray<SkAutoTUnref<SkTypeface>, true> fStyles;
-
-    friend struct NameToFamily;
-    friend class SkFontMgr_Android;
-
-    typedef SkFontStyleSet INHERITED;
-};
-
-/** On Android a single family can have many names, but our API assumes unique names.
- *  Map names to the back end so that all names for a given family refer to the same
- *  (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);
-        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();
-    }
-
-    virtual void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
-        if (index < 0 || fNameToFamilyMap.count() <= index) {
-            familyName->reset();
-            return;
-        }
-        familyName->set(fNameToFamilyMap[index].name);
-    }
-
-    virtual SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
-        if (index < 0 || fNameToFamilyMap.count() <= index) {
-            return NULL;
-        }
-        return SkRef(fNameToFamilyMap[index].styleSet);
-    }
-
-    virtual SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
-        if (!familyName) {
-            return NULL;
-        }
-        SkAutoAsciiToLC tolc(familyName);
-        for (int i = 0; i < fNameToFamilyMap.count(); ++i) {
-            if (fNameToFamilyMap[i].name.equals(tolc.lc())) {
-                return SkRef(fNameToFamilyMap[i].styleSet);
-            }
-        }
-        return NULL;
-    }
-
-    virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
-                                           const SkFontStyle& style) const SK_OVERRIDE {
-        SkAutoTUnref<SkFontStyleSet> sset(this->matchFamily(familyName));
-        return sset->matchStyle(style);
-    }
-
-    virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
-                                         const SkFontStyle& style) const SK_OVERRIDE {
-        for (int i = 0; i < fFontStyleSets.count(); ++i) {
-            for (int j = 0; j < fFontStyleSets[i]->fStyles.count(); ++j) {
-                if (fFontStyleSets[i]->fStyles[j] == typeface) {
-                    return fFontStyleSets[i]->matchStyle(style);
-                }
-            }
-        }
-        return NULL;
-    }
-
-    virtual SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
-        SkAutoTUnref<SkStream> stream(new SkMemoryStream(data));
-        return this->createFromStream(stream, ttcIndex);
-    }
-
-    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;
-    }
-
-    virtual SkTypeface* onCreateFromStream(SkStream* s, int ttcIndex) const SK_OVERRIDE {
-        SkAutoTUnref<SkStream> stream(s);
-
-        bool isFixedPitch;
-        SkTypeface::Style style;
-        SkString name;
-        if (!SkTypeface_FreeType::ScanFont(stream, ttcIndex, &name, &style, &isFixedPitch)) {
-            return NULL;
-        }
-        return SkNEW_ARGS(SkTypeface_AndroidStream, (stream.detach(), ttcIndex,
-                                                     style, isFixedPitch, name));
-    }
-
-
-    virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
-                                               unsigned styleBits) const SK_OVERRIDE {
-        SkTypeface::Style oldStyle = (SkTypeface::Style)styleBits;
-        SkFontStyle style = SkFontStyle(oldStyle & SkTypeface::kBold
-                                                 ? SkFontStyle::kBold_Weight
-                                                 : SkFontStyle::kNormal_Weight,
-                                        SkFontStyle::kNormal_Width,
-                                        oldStyle & SkTypeface::kItalic
-                                                 ? SkFontStyle::kItalic_Slant
-                                                 : SkFontStyle::kUpright_Slant);
-        SkTypeface* tf = NULL;
-
-        if (NULL != familyName) {
-            // On Android, we must return NULL when we can't find the requested
-            // named typeface so that the system/app can provide their own recovery
-            // mechanism. On other platforms we'd provide a typeface from the
-            // default family instead.
-            tf = this->onMatchFamilyStyle(familyName, style);
-        } else {
-            tf = fDefaultFamily->matchStyle(style);
-        }
-
-        // TODO: double ref? qv matchStyle()
-        return SkSafeRef(tf);
-    }
-
-
-private:
-
-    SkTArray<SkAutoTUnref<SkFontStyleSet_Android>, true> fFontStyleSets;
-    SkFontStyleSet* fDefaultFamily;
-    SkTypeface* fDefaultTypeface;
-
-    SkTDArray<NameToFamily> fNameToFamilyMap;
-
-    void buildNameToFamilyMap(SkTDArray<FontFamily*> families) {
-        for (int i = 0; i < families.count(); i++) {
-            fFontStyleSets.push_back().reset(
-                SkNEW_ARGS(SkFontStyleSet_Android, (families[i])));
-            for (int j = 0; j < families[i]->fNames.count(); j++) {
-                NameToFamily* nextEntry = fNameToFamilyMap.append();
-                SkNEW_PLACEMENT_ARGS(&nextEntry->name, SkString, (families[i]->fNames[j]));
-                nextEntry->styleSet = fFontStyleSets.back().get();
-            }
-        }
-    }
-
-    void findDefaultFont() {
-        SkASSERT(!fFontStyleSets.empty());
-
-        static const char* gDefaultNames[] = { "sans-serif" };
-        for (size_t i = 0; i < SK_ARRAY_COUNT(gDefaultNames); ++i) {
-            SkFontStyleSet* set = this->onMatchFamily(gDefaultNames[i]);
-            if (NULL == set) {
-                continue;
-            }
-            SkTypeface* tf = set->matchStyle(SkFontStyle());
-            if (NULL == tf) {
-                continue;
-            }
-            fDefaultFamily = set;
-            fDefaultTypeface = tf;
-            break;
-        }
-        if (NULL == fDefaultTypeface) {
-            fDefaultFamily = fFontStyleSets[0];
-            fDefaultTypeface = fDefaultFamily->createTypeface(0);
-        }
-        SkASSERT(fDefaultFamily);
-        SkASSERT(fDefaultTypeface);
-    }
-
-    typedef SkFontMgr INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkFontMgr* SkFontMgr::Factory() {
-    return SkNEW(SkFontMgr_Android);
-}
-
-
-