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

trunk/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"
@@ skipping 240 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; }
     FamilyRec* getFamily() const { return fFamilyRec; }
-    // openStream returns a SkStream that has been ref-ed
-    virtual SkStream* openStream() = 0;
+
     virtual const char* getUniqueString() const = 0;
 
 private:
     FamilyRec*  fFamilyRec; // we don't own this, just point to it
     bool        fIsSysFont;
 
     typedef SkTypeface_FreeType INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /* This subclass is just a place holder for when we have no fonts available.
     It exists so that our globals (e.g. gFamilyHead) that expect *something*
     will not be null.
  */
 class EmptyTypeface : public FamilyTypeface {
 public:
     EmptyTypeface() : INHERITED(SkTypeface::kNormal, true, NULL, false) {}
 
-    // overrides
-    virtual SkStream* openStream() SK_OVERRIDE { return NULL; }
     virtual const char* getUniqueString() SK_OVERRIDE const { return NULL; }
 
+protected:
+    virtual SkStream* onOpenStream(int*) const SK_OVERRIDE { return NULL; }
+
 private:
     typedef FamilyTypeface INHERITED;
 };
 
 class StreamTypeface : public FamilyTypeface {
 public:
     StreamTypeface(Style style, bool sysFont, FamilyRec* family,
                    SkStream* stream, bool isFixedWidth)
     : INHERITED(style, sysFont, family, isFixedWidth) {
         stream->ref();
         fStream = stream;
     }
     virtual ~StreamTypeface() {
         fStream->unref();
     }
 
-    virtual SkStream* openStream() SK_OVERRIDE {
-      // openStream returns a refed stream.
-      fStream->ref();
-      return fStream;
+    virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
+
+protected:
+    virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+        *ttcIndex = 0;
+        fStream->ref();
+        return fStream;
     }
-    virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
 
 private:
     SkStream* fStream;
 
     typedef FamilyTypeface INHERITED;
 };
 
 class FileTypeface : public FamilyTypeface {
 public:
     FileTypeface(Style style, bool sysFont, FamilyRec* family,
                  const char path[], bool isFixedWidth)
         : INHERITED(style, sysFont, family, isFixedWidth) {
         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;
     }
 
+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 113 matching lines @@
     SkFontDescriptor descriptor;
     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 43 matching lines @@
     }
 
     if (NULL == tf) {
         tf = find_best_face(gDefaultFamily, style);
     }
 
     SkSafeRef(tf);
     return tf;
 }
 
-SkStream* SkFontHost::OpenStream(uint32_t fontID) {
-    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) {
     return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkTypeface* SkFontHost::CreateTypefaceFromStream(SkStream* stream) {
     if (NULL == stream || stream->getLength() <= 0) {
         SkDELETE(stream);
         return NULL;
     }
 
     bool isFixedWidth;
     SkTypeface::Style style;
     if (find_name_and_attributes(stream, NULL, &style, &isFixedWidth)) {
         return SkNEW_ARGS(StreamTypeface, (style, false, NULL, stream, isFixedWidth));
     } else {
         return NULL;
     }
 }
 
 SkTypeface* SkFontHost::CreateTypefaceFromFile(const char path[]) {
     SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
     return stream.get() ? CreateTypefaceFromStream(stream) : NULL;
 }