Serialize the font index.

src/core/SkFontDescriptor.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontDescriptor.h"
 #include "SkStream.h"
 
 enum {
     // these must match the sfnt 'name' enums
     kFontFamilyName = 0x01,
     kFullName       = 0x04,
     kPostscriptName = 0x06,
 
     // These count backwards from 0xFF, so as not to collide with the SFNT
     // defines for names in its 'name' table.
+    kFontFileIndex  = 0xFD,
     kFontFileName   = 0xFE,
     kSentinel       = 0xFF,
 };
 
-SkFontDescriptor::SkFontDescriptor(SkTypeface::Style style) {
-    fStyle = style;
-}
+SkFontDescriptor::SkFontDescriptor(SkTypeface::Style style) : fFontFileIndex(0), fStyle(style) { }

[bungeman-skia, 2014/09/15 15:52:07]

So I took a look into an 'unknown' or 'isn't a collection' value. As a survey,
DirectWrite has IDWriteFontFace::GetIndex() which will return 0 if the font file
contains a single face in all cases. FontConfig will store 0 for the FC_INDEX
for any such font. This is mostly because FreeType always treats the first face
in a file as index 0. As a result, our Android back-end behaves this way. GDI
and CT/CG are basically collection antagonistic at the API layer, and won't tell
you what the index is.

In a certain sense, all font files are collections with at least a '0' entry,
and all of our back-ends treat the situation this way. In general we would have
to write extra code to distinguish between these cases, and we would also have
to write yet more extra code to handle this extra case. For all this extra code
it does not appear that we receive any benefit. For consistency with existing
practice, and to reduce superfluous code, I recommend sticking with '0' instead
of something like '-1' for non-collection font file formats.

Regarding setting the fFontFileIndex to '-1' only if fFontFileName is left empty
and fFontFileIndex is not set. This would imply some odd behavior like setting
the fFontFileIndex to '-1' in the constructor and then in setFontFileName
setting fFontFileIndex to '0' if it is currently '-1'. On the other side when
reading this information what do we do with it? If fFontFileName is
inaccessible, we won't be using fFontFileIndex anyway; I can't imagine anyone
would be checking fFontFileIndex as some sort of signal as to the validity of
fFontFileName. It is easier to see the converse, that a non-empty and valid
fFontFileName implies a valid fFontFileIndex.

Much of this seems to stem from the fact that the font stream (when needed) is
separate from this descriptor. This implies we need the index in two places, one
for the file name and one for the stream. Perhaps the correct answer to this is
to get rid of the 'isLocal' from onGetFontDescriptor and add a setStream to
SkFontDescriptor.

 
 static void read_string(SkStream* stream, SkString* string) {
     const uint32_t length = SkToU32(stream->readPackedUInt());
     if (length > 0) {
         string->resize(length);
         stream->read(string->writable_str(), length);
     }
 }
 
 static void write_string(SkWStream* stream, const SkString& string,
                          uint32_t id) {
     if (!string.isEmpty()) {
         stream->writePackedUInt(id);
         stream->writePackedUInt(string.size());
         stream->write(string.c_str(), string.size());
     }
 }
 
-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) : fFontFileIndex(0) {
     fStyle = (SkTypeface::Style)stream->readPackedUInt();
 
     for (;;) {
         switch (stream->readPackedUInt()) {
             case kFontFamilyName:
                 read_string(stream, &fFamilyName);
                 break;
             case kFullName:
                 read_string(stream, &fFullName);
                 break;
             case kPostscriptName:
                 read_string(stream, &fPostscriptName);
                 break;
+            case kFontFileIndex:
+                fFontFileIndex = read_uint(stream);
+                break;
             case kFontFileName:
                 read_string(stream, &fFontFileName);
                 break;
             case kSentinel:
                 return;
             default:
                 SkDEBUGFAIL("Unknown id used by a font descriptor");
                 return;
         }
     }
 }
 
 void SkFontDescriptor::serialize(SkWStream* stream) {
     stream->writePackedUInt(fStyle);
 
     write_string(stream, fFamilyName, kFontFamilyName);
     write_string(stream, fFullName, kFullName);
     write_string(stream, fPostscriptName, kPostscriptName);
     write_string(stream, fFontFileName, kFontFileName);
+    write_uint(stream, fFontFileIndex, kFontFileIndex);
 
     stream->writePackedUInt(kSentinel);
 }