Correct Android FontMgr use of ttc index and remove unused code.

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"
@@ skipping 102 matching lines @@
 };
 
 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) {
+    explicit SkFontStyleSet_Android(FontFamily* 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;
             }
 
+            const int ttcIndex = family->fFontFiles[i].fIndex;
             SkString fontName;
             SkTypeface::Style style;
             bool isFixedWidth;
-            if (!SkTypeface_FreeType::ScanFont(stream.get(), family->fFontFiles[i].fIndex,
+            if (!SkTypeface_FreeType::ScanFont(stream.get(), ttcIndex,
                                                &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,
+                                                 (pathName, ttcIndex,
                                                   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;
@@ skipping 47 matching lines @@
         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
@@ skipping 95 matching lines @@
     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);
+            return this->onMatchFamilyStyle(familyName, style);
         }
-
-        // TODO: double ref? qv matchStyle()
-        return SkSafeRef(tf);
+        return fDefaultFamily->matchStyle(style);
     }
 
 
 private:
 
     SkTArray<SkAutoTUnref<SkFontStyleSet_Android>, true> fFontStyleSets;
     SkFontStyleSet* fDefaultFamily;
     SkTypeface* fDefaultTypeface;
 
     SkTDArray<NameToFamily> fNameToFamilyMap;
@@ skipping 36 matching lines @@
     }
 
     typedef SkFontMgr INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_Android);
 }