diff --git a/include/core/SkRefCnt.h b/include/core/SkRefCnt.h
index f092e77..459ad25 100644
--- a/include/core/SkRefCnt.h
+++ b/include/core/SkRefCnt.h
@@ -234,7 +234,7 @@
     BlockRefType *operator->() const {
         return static_cast<BlockRefType*>(fObj);
     }
-    operator T*() { return fObj; }
+    operator T*() const { return fObj; }
 
 private:
     T*  fObj;
diff --git a/include/core/SkTypeface.h b/include/core/SkTypeface.h
index 1df467a..cb87a6a 100644
--- a/include/core/SkTypeface.h
+++ b/include/core/SkTypeface.h
@@ -114,13 +114,13 @@
     /** Return a new typeface given a file. If the file does not exist, or is
         not a valid font file, returns null.
     */
-    static SkTypeface* CreateFromFile(const char path[]);
+    static SkTypeface* CreateFromFile(const char path[], int index = 0);
 
     /** Return a new typeface given a stream. If the stream is
         not a valid font file, returns null. Ownership of the stream is
         transferred, so the caller must not reference it again.
     */
-    static SkTypeface* CreateFromStream(SkStream* stream);
+    static SkTypeface* CreateFromStream(SkStream* stream, int index = 0);
 
     /** Write a unique signature to a stream, sufficient to reconstruct a
         typeface referencing the same font when Deserialize is called.
diff --git a/src/core/SkFontDescriptor.cpp b/src/core/SkFontDescriptor.cpp
index 5088ed7..7426894 100644
--- a/src/core/SkFontDescriptor.cpp
+++ b/src/core/SkFontDescriptor.cpp
@@ -7,6 +7,7 @@
 
 #include "SkFontDescriptor.h"
 #include "SkStream.h"
+#include <SkData.h>
 
 enum {
     // these must match the sfnt 'name' enums
@@ -16,13 +17,12 @@
 
     // These count backwards from 0xFF, so as not to collide with the SFNT
     // defines for names in its 'name' table.
+    kFontIndex      = 0xFD,
     kFontFileName   = 0xFE,
     kSentinel       = 0xFF,
 };
 
-SkFontDescriptor::SkFontDescriptor(SkTypeface::Style style) {
-    fStyle = style;
-}
+SkFontDescriptor::SkFontDescriptor(SkTypeface::Style style) : fFontIndex(0), fStyle(style) { }
 
 static void read_string(SkStream* stream, SkString* string) {
     const uint32_t length = SkToU32(stream->readPackedUInt());
@@ -41,11 +41,20 @@
     }
 }
 
-SkFontDescriptor::SkFontDescriptor(SkStream* stream) {
+static size_t read_uint(SkStream* stream) {
+    return stream->readPackedUInt();
+}
+
+static void write_uint(SkWStream* stream, size_t n, uint32_t id) {
+    stream->writePackedUInt(id);
+    stream->writePackedUInt(n);
+}
+
+SkFontDescriptor::SkFontDescriptor(SkStream* stream) : fFontIndex(0) {
     fStyle = (SkTypeface::Style)stream->readPackedUInt();
 
-    for (;;) {
-        switch (stream->readPackedUInt()) {
+    for (size_t id; (id = stream->readPackedUInt()) != kSentinel;) {
+        switch (id) {
             case kFontFamilyName:
                 read_string(stream, &fFamilyName);
                 break;
@@ -55,16 +64,25 @@
             case kPostscriptName:
                 read_string(stream, &fPostscriptName);
                 break;
+            case kFontIndex:
+                fFontIndex = read_uint(stream);
+                break;
             case kFontFileName:
                 read_string(stream, &fFontFileName);
                 break;
-            case kSentinel:
-                return;
             default:
                 SkDEBUGFAIL("Unknown id used by a font descriptor");
                 return;
         }
     }
+
+    size_t length = stream->readPackedUInt();
+    if (length > 0) {
+        SkAutoTUnref<SkData> data(SkData::NewUninitialized(length));
+        if (stream->read(data->writable_data(), length) == length) {
+            fFontData.reset(SkNEW_ARGS(SkMemoryStream, (data)));
+        }
+    }
 }
 
 void SkFontDescriptor::serialize(SkWStream* stream) {
@@ -74,6 +92,17 @@
     write_string(stream, fFullName, kFullName);
     write_string(stream, fPostscriptName, kPostscriptName);
     write_string(stream, fFontFileName, kFontFileName);
+    if (fFontIndex) {
+        write_uint(stream, fFontIndex, kFontIndex);
+    }
 
     stream->writePackedUInt(kSentinel);
+
+    if (fFontData) {
+        size_t length = fFontData->getLength();
+        stream->writePackedUInt(length);
+        stream->writeStream(fFontData, length);
+    } else {
+        stream->writePackedUInt(0);
+    }
 }
diff --git a/src/core/SkFontDescriptor.h b/src/core/SkFontDescriptor.h
index 5febfd8..5a6ddd5 100644
--- a/src/core/SkFontDescriptor.h
+++ b/src/core/SkFontDescriptor.h
@@ -8,10 +8,10 @@
 #ifndef SkFontDescriptor_DEFINED
 #define SkFontDescriptor_DEFINED
 
+#include "SkStream.h"
 #include "SkString.h"
 #include "SkTypeface.h"
 
-class SkStream;
 class SkWStream;
 
 class SkFontDescriptor {
@@ -24,21 +24,30 @@
     SkTypeface::Style getStyle() { return fStyle; }
     void setStyle(SkTypeface::Style style) { fStyle = style; }
 
-    const char* getFamilyName() { return fFamilyName.c_str(); }
-    const char* getFullName() { return fFullName.c_str(); }
-    const char* getPostscriptName() { return fPostscriptName.c_str(); }
-    const char* getFontFileName() { return fFontFileName.c_str(); }
+    const char* getFamilyName() const { return fFamilyName.c_str(); }
+    const char* getFullName() const { return fFullName.c_str(); }
+    const char* getPostscriptName() const { return fPostscriptName.c_str(); }
+    const char* getFontFileName() const { return fFontFileName.c_str(); }
+    SkStream* getFontData() const { return fFontData; }
+    int getFontIndex() const { return fFontIndex; }
 
     void setFamilyName(const char* name) { fFamilyName.set(name); }
     void setFullName(const char* name) { fFullName.set(name); }
     void setPostscriptName(const char* name) { fPostscriptName.set(name); }
     void setFontFileName(const char* name) { fFontFileName.set(name); }
+    /** Set the font data only if it is necessary for serialization.
+     *  This method takes ownership of the stream (both reference and cursor).
+     */
+    void setFontData(SkStream* stream) { fFontData.reset(stream); }
+    void setFontIndex(int index) { fFontIndex = index; }
 
 private:
     SkString fFamilyName;
     SkString fFullName;
     SkString fPostscriptName;
     SkString fFontFileName;
+    SkAutoTUnref<SkStream> fFontData;
+    int fFontIndex;
 
     SkTypeface::Style fStyle;
 };
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index 1c2f8e8..88bde22 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -2308,19 +2308,15 @@
 
 #ifndef SK_IGNORE_TO_STRING
 
-static SkFontDescriptor typeface_getDescriptor(const SkTypeface* face) {
-    SkDynamicMemoryWStream ostream;
-    face->serialize(&ostream);
-    SkAutoTUnref<SkStreamAsset> istream(ostream.detachAsStream());
-    return SkFontDescriptor(istream);
-}
-
 void SkPaint::toString(SkString* str) const {
     str->append("<dl><dt>SkPaint:</dt><dd><dl>");
 
     SkTypeface* typeface = this->getTypeface();
     if (typeface) {
-        SkFontDescriptor descriptor(typeface_getDescriptor(typeface));
+        SkDynamicMemoryWStream ostream;
+        typeface->serialize(&ostream);
+        SkAutoTUnref<SkStreamAsset> istream(ostream.detachAsStream());
+        SkFontDescriptor descriptor(istream);
 
         str->append("<dt>Font Family Name:</dt><dd>");
         str->append(descriptor.getFamilyName());
diff --git a/src/core/SkTypeface.cpp b/src/core/SkTypeface.cpp
index 74dd5d9..d7da131 100644
--- a/src/core/SkTypeface.cpp
+++ b/src/core/SkTypeface.cpp
@@ -147,14 +147,14 @@
     return fm->matchFaceStyle(family, newStyle);
 }
 
-SkTypeface* SkTypeface::CreateFromStream(SkStream* stream) {
+SkTypeface* SkTypeface::CreateFromStream(SkStream* stream, int index) {
     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
-    return fm->createFromStream(stream);
+    return fm->createFromStream(stream, index);
 }
 
-SkTypeface* SkTypeface::CreateFromFile(const char path[]) {
+SkTypeface* SkTypeface::CreateFromFile(const char path[], int index) {
     SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
-    return fm->createFromFile(path);
+    return fm->createFromFile(path, index);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -164,45 +164,24 @@
     SkFontDescriptor desc(this->style());
     this->onGetFontDescriptor(&desc, &isLocal);
 
-    desc.serialize(wstream);
-    if (isLocal) {
-        int ttcIndex;   // TODO: write this to the stream?
-        SkAutoTUnref<SkStream> rstream(this->openStream(&ttcIndex));
-        if (rstream.get()) {
-            size_t length = rstream->getLength();
-            wstream->writePackedUInt(length);
-            wstream->writeStream(rstream, length);
-        } else {
-            wstream->writePackedUInt(0);
-        }
-    } else {
-        wstream->writePackedUInt(0);
+    if (isLocal && NULL == desc.getFontData()) {
+        int ttcIndex;
+        desc.setFontData(this->onOpenStream(&ttcIndex));
+        desc.setFontIndex(ttcIndex);
     }
+
+    desc.serialize(wstream);
 }
 
 SkTypeface* SkTypeface::Deserialize(SkStream* stream) {
     SkFontDescriptor desc(stream);
-    size_t length = stream->readPackedUInt();
-    if (length > 0) {
-        void* addr = sk_malloc_flags(length, 0);
-        if (addr) {
-            SkAutoTUnref<SkMemoryStream> localStream(SkNEW(SkMemoryStream));
-            localStream->setMemoryOwned(addr, length);
-
-            if (stream->read(addr, length) == length) {
-                return SkTypeface::CreateFromStream(localStream.get());
-            } else {
-                // Failed to read the full font data, so fall through and try to create from name.
-                // If this is because of EOF, all subsequent reads from the stream will be EOF.
-                // If this is because of a stream error, the stream is in an error state,
-                // do not attempt to skip any remaining bytes.
-            }
-        } else {
-            // failed to allocate, so just skip and create-from-name
-            stream->skip(length);
+    SkStream* data = desc.getFontData();
+    if (data) {
+        SkTypeface* typeface = SkTypeface::CreateFromStream(data, desc.getFontIndex());
+        if (typeface) {
+            return typeface;
         }
     }
-
     return SkTypeface::CreateFromName(desc.getFamilyName(), desc.getStyle());
 }
 
diff --git a/src/ports/SkFontHost_fontconfig.cpp b/src/ports/SkFontHost_fontconfig.cpp
index 57252d0..b3a893e 100644
--- a/src/ports/SkFontHost_fontconfig.cpp
+++ b/src/ports/SkFontHost_fontconfig.cpp
@@ -169,5 +169,6 @@
 void FontConfigTypeface::onGetFontDescriptor(SkFontDescriptor* desc,
                                              bool* isLocalStream) const {
     desc->setFamilyName(this->getFamilyName());
+    desc->setFontIndex(this->getIdentity().fTTCIndex);
     *isLocalStream = SkToBool(this->getLocalStream());
 }
diff --git a/src/ports/SkFontHost_linux.cpp b/src/ports/SkFontHost_linux.cpp
index 2904cac..a4202aa 100644
--- a/src/ports/SkFontHost_linux.cpp
+++ b/src/ports/SkFontHost_linux.cpp
@@ -30,9 +30,10 @@
 /** The base SkTypeface implementation for the custom font manager. */
 class SkTypeface_Custom : public SkTypeface_FreeType {
 public:
-    SkTypeface_Custom(Style style, bool isFixedPitch, bool sysFont, const SkString familyName)
+    SkTypeface_Custom(Style style, bool isFixedPitch,
+                      bool sysFont, const SkString familyName, int index)
         : INHERITED(style, SkTypefaceCache::NewFontID(), isFixedPitch)
-        , fIsSysFont(sysFont), fFamilyName(familyName)
+        , fIsSysFont(sysFont), fFamilyName(familyName), fIndex(index)
     { }
 
     bool isSysFont() const { return fIsSysFont; }
@@ -47,12 +48,16 @@
     virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocal) const SK_OVERRIDE {
         desc->setFamilyName(fFamilyName.c_str());
         desc->setFontFileName(this->getUniqueString());
+        desc->setFontIndex(fIndex);
         *isLocal = !this->isSysFont();
     }
 
+    int getIndex() const { return fIndex; }
+
 private:
-    bool fIsSysFont;
-    SkString fFamilyName;
+    const bool fIsSysFont;
+    const SkString fFamilyName;
+    const int fIndex;
 
     typedef SkTypeface_FreeType INHERITED;
 };
@@ -62,7 +67,7 @@
  */
 class SkTypeface_Empty : public SkTypeface_Custom {
 public:
-    SkTypeface_Empty() : INHERITED(SkTypeface::kNormal, false, true, SkString()) {}
+    SkTypeface_Empty() : INHERITED(SkTypeface::kNormal, false, true, SkString(), 0) {}
 
     virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
 
@@ -78,21 +83,20 @@
 public:
     SkTypeface_Stream(Style style, bool isFixedPitch, bool sysFont, const SkString familyName,
                       SkStream* stream, int ttcIndex)
-        : INHERITED(style, isFixedPitch, sysFont, familyName)
-        , fStream(SkRef(stream)), fTtcIndex(ttcIndex)
+        : INHERITED(style, isFixedPitch, sysFont, familyName, ttcIndex)
+        , fStream(SkRef(stream))
     { }
 
     virtual const char* getUniqueString() const SK_OVERRIDE { return NULL; }
 
 protected:
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
-        *ttcIndex = 0;
+        *ttcIndex = this->getIndex();
         return fStream->duplicate();
     }
 
 private:
-    SkAutoTUnref<SkStream> fStream;
-    int fTtcIndex;
+    const SkAutoTUnref<const SkStream> fStream;
 
     typedef SkTypeface_Custom INHERITED;
 };
@@ -101,8 +105,8 @@
 class SkTypeface_File : public SkTypeface_Custom {
 public:
     SkTypeface_File(Style style, bool isFixedPitch, bool sysFont, const SkString familyName,
-                    const char path[])
-        : INHERITED(style, isFixedPitch, sysFont, familyName)
+                    const char path[], int index)
+        : INHERITED(style, isFixedPitch, sysFont, familyName, index)
         , fPath(path)
     { }
 
@@ -116,7 +120,7 @@
 
 protected:
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
-        *ttcIndex = 0;
+        *ttcIndex = this->getIndex();
         return SkStream::NewFromFile(fPath.c_str());
     }
 
@@ -343,7 +347,7 @@
                                                 isFixedPitch,
                                                 true,  // system-font (cannot delete)
                                                 realname,
-                                                filename.c_str()));
+                                                filename.c_str(), 0));
 
             SkFontStyleSet_Custom* addTo = this->onMatchFamily(realname.c_str());
             if (NULL == addTo) {
diff --git a/src/ports/SkFontMgr_android.cpp b/src/ports/SkFontMgr_android.cpp
index 2fee735..5e93bf8 100644
--- a/src/ports/SkFontMgr_android.cpp
+++ b/src/ports/SkFontMgr_android.cpp
@@ -81,6 +81,7 @@
         SkASSERT(serialize);
         desc->setFamilyName(fFamilyName.c_str());
         desc->setFontFileName(fPathName.c_str());
+        desc->setFontIndex(fIndex);
         *serialize = false;
     }
     virtual SkStream* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
diff --git a/src/ports/SkFontMgr_fontconfig.cpp b/src/ports/SkFontMgr_fontconfig.cpp
index f4cae23..00b962a 100644
--- a/src/ports/SkFontMgr_fontconfig.cpp
+++ b/src/ports/SkFontMgr_fontconfig.cpp
@@ -394,7 +394,7 @@
     }
 
     virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
-        desc->setStyle(this->style());
+        desc->setFontIndex(fIndex);
         *serialize = true;
     }
 
@@ -425,10 +425,10 @@
     virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
         FCLocker lock;
         desc->setFamilyName(get_string(fPattern, FC_FAMILY));
-        desc->setFontFileName(get_string(fPattern, FC_FILE));
         desc->setFullName(get_string(fPattern, FC_FULLNAME));
         desc->setPostscriptName(get_string(fPattern, FC_POSTSCRIPT_NAME));
-        desc->setStyle(this->style());
+        desc->setFontFileName(get_string(fPattern, FC_FILE));
+        desc->setFontIndex(get_int(fPattern, FC_INDEX, 0));
         *serialize = false;
     }
 
diff --git a/src/ports/SkTypeface_win_dw.cpp b/src/ports/SkTypeface_win_dw.cpp
index 9c2b41d..8b9ed16 100644
--- a/src/ports/SkTypeface_win_dw.cpp
+++ b/src/ports/SkTypeface_win_dw.cpp
@@ -42,6 +42,7 @@
     sk_get_locale_string(familyNames.get(), NULL/*fMgr->fLocaleName.get()*/, &utf8FamilyName);
 
     desc->setFamilyName(utf8FamilyName.c_str());
+    desc->setFontIndex(fDWriteFontFace->GetIndex());
     *isLocalStream = SkToBool(fDWriteFontFileLoader.get());
 }
 
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index 23cc33d..b6ee978 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -301,7 +301,7 @@
         return;
     }
     SkString filename = SkOSPath::Join(resourcePath.c_str(), "test.ttc");
-    SkTypeface* typeface = SkTypeface::CreateFromFile(filename.c_str());
+    SkTypeface* typeface = SkTypeface::CreateFromFile(filename.c_str(), 1);
     if (!typeface) {
         SkDebugf("Could not run fontstream test because test.ttc not found.");
         return;
@@ -320,7 +320,7 @@
                                                SkIntToScalar(canvasRect.height()), 
                                                NULL, 0);
     canvas->drawColor(SK_ColorWHITE);
-    canvas->drawText("A", 1, 24, 32, paint);
+    canvas->drawText("A!", 2, 24, 32, paint);
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     // Serlialize picture and create its clone from stream.