remove SkFontHost::OpenStream(), now subsumed by SkTypeface::openStream()

trunk/src/ports/SkFontHost_android.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"
@@ skipping 295 matching lines @@
         // that and then remove that family from the name list
         FamilyRec* family = remove_from_family(this);
         if (NULL != family) {
             remove_from_names(family);
             detach_and_delete_family(family);
         }
     }
 
     bool isSysFont() const { return fIsSysFont; }
 
-    virtual SkStream* openStream() = 0;
     virtual const char* getUniqueString() const = 0;
     virtual const char* getFilePath() const = 0;
 
 private:
     bool    fIsSysFont;
 
     typedef SkTypeface_FreeType INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class StreamTypeface : public FamilyTypeface {
 public:
     StreamTypeface(Style style, bool sysFont, SkTypeface* familyMember,
                    SkStream* stream, bool isFixedWidth)
     : INHERITED(style, sysFont, familyMember, isFixedWidth) {
         SkASSERT(stream);
         stream->ref();
         fStream = stream;
     }
     virtual ~StreamTypeface() {
         fStream->unref();
     }
 
-    // overrides
-    virtual SkStream* openStream() {
+    virtual const char* getUniqueString() SK_OVERRIDE const { return NULL; }
+    virtual const char* getFilePath() SK_OVERRIDE const { return NULL; }
+
+protected:
+    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+        *ttcIndex = 0;
         // we just ref our existing stream, since the caller will call unref()
         // when they are through
         fStream->ref();
         // must rewind each time, since the caller assumes a "new" stream
         fStream->rewind();
         return fStream;
     }
-    virtual const char* getUniqueString() const { return NULL; }
-    virtual const char* getFilePath() const { return NULL; }
 
 private:
     SkStream* fStream;
 
     typedef FamilyTypeface INHERITED;
 };
 
 class FileTypeface : public FamilyTypeface {
 public:
     FileTypeface(Style style, bool sysFont, SkTypeface* familyMember,
                  const char path[], bool isFixedWidth)
     : INHERITED(style, sysFont, familyMember, isFixedWidth) {
         SkString fullpath;
 
         if (sysFont) {
             GetFullPathForSysFonts(&fullpath, path);
             path = fullpath.c_str();
         }
         fPath.set(path);
     }
 
-    virtual SkStream* openStream() SK_OVERRIDE {
-        return SkStream::NewFromFile(fPath.c_str());
-    }
-
     virtual const char* getUniqueString() const SK_OVERRIDE {
         const char* str = strrchr(fPath.c_str(), '/');
         if (str) {
             str += 1;   // skip the '/'
         }
         return str;
     }
 
     virtual const char* getFilePath() const SK_OVERRIDE {
         return fPath.c_str();
     }
 
+protected:
+    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+        *ttcIndex = 0;
+        return SkStream::NewFromFile(fPath.c_str());
+    }
+
 private:
     SkString fPath;
 
     typedef FamilyTypeface INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool get_name_and_style(const char path[], SkString* name,
@@ skipping 343 matching lines @@
         descriptor.setFamilyName(find_family_name(face));
         descriptor.setStyle(face->style());
         descriptor.setFontFileName(((FamilyTypeface*)face)->getUniqueString());
     }
 
     descriptor.serialize(stream);
 
     const bool isCustomFont = !((FamilyTypeface*)face)->isSysFont();
     if (isCustomFont) {
         // store the entire font in the fontData
-        SkStream* fontStream = ((FamilyTypeface*)face)->openStream();
+        SkStream* fontStream = face->openStream(NULL);
         const uint32_t length = fontStream->getLength();
 
         stream->writePackedUInt(length);
         stream->writeStream(fontStream, length);
 
         fontStream->unref();
     } else {
         stream->writePackedUInt(0);
     }
 }
@@ skipping 63 matching lines @@
 
     if (NULL == tf) {
         tf = find_best_face(gDefaultFamily, style);
     }
 
     // we ref(), since the semantic is to return a new instance
     tf->ref();
     return tf;
 }
 
-SkStream* SkFontHost::OpenStream(uint32_t fontID) {
-    SkAutoMutexAcquire  ac(gFamilyHeadAndNameListMutex);
-
-    FamilyTypeface* tf = (FamilyTypeface*)find_from_uniqueID(fontID);
-    SkStream* stream = tf ? tf->openStream() : NULL;
-
-    if (stream && stream->getLength() == 0) {
-        stream->unref();
-        stream = NULL;
-    }
-    return stream;
-}
-
 SkTypeface* SkFontHost::NextLogicalTypeface(SkFontID currFontID, SkFontID origFontID) {
 #if defined(SK_BUILD_FOR_ANDROID) && !defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
     // Skia does not support font fallback for ndk applications in order to
     // enable clients such as WebKit to customize their font selection.
     // Clients can use GetFallbackFamilyNameForChar() to get the fallback
     // font for individual characters.
     return NULL;
 #else
     SkAutoMutexAcquire  ac(gFamilyHeadAndNameListMutex);
 
@@ skipping 242 matching lines @@
                              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));
 }