Make skpinfo able to inspect SK_PICT_TYPEFACE_TAG blocks

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"
 #include "SkData.h"
@@ skipping 40 matching lines @@
 
 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) {
-    fStyle = (SkTypeface::Style)stream->readPackedUInt();
+bool SkFontDescriptor::Deserialize(SkStream* stream, SkFontDescriptor* result) {
+    result->fStyle = (SkTypeface::Style)stream->readPackedUInt();
 
     SkAutoSTMalloc<4, SkFixed> axis;
     size_t axisCount = 0;
     size_t index = 0;
     for (size_t id; (id = stream->readPackedUInt()) != kSentinel;) {
         switch (id) {
             case kFontFamilyName:
-                read_string(stream, &fFamilyName);
+                read_string(stream, &result->fFamilyName);
                 break;
             case kFullName:
-                read_string(stream, &fFullName);
+                read_string(stream, &result->fFullName);
                 break;
             case kPostscriptName:
-                read_string(stream, &fPostscriptName);
+                read_string(stream, &result->fPostscriptName);
                 break;
             case kFontAxes:
                 axisCount = read_uint(stream);
                 axis.reset(axisCount);
                 for (size_t i = 0; i < axisCount; ++i) {
                     axis[i] = read_uint(stream);
                 }
                 break;
             case kFontIndex:
                 index = read_uint(stream);
                 break;
             case kFontFileName:  // Remove when MIN_PICTURE_VERSION > 41
                 skip_string(stream);
                 break;
             default:
                 SkDEBUGFAIL("Unknown id used by a font descriptor");
-                return;
+                return false;
         }
     }
 
     size_t length = stream->readPackedUInt();
     if (length > 0) {
         SkAutoTUnref<SkData> data(SkData::NewUninitialized(length));
         if (stream->read(data->writable_data(), length) == length) {
-            fFontData.reset(new SkFontData(new SkMemoryStream(data), index, axis, axisCount));
+            result->fFontData.reset(new SkFontData(new SkMemoryStream(data),
+                                                   index, axis, axisCount));
+        } else {
+            return false;

[bungeman-skia, 2016/02/25 15:41:17]

For consistency with the above 'default' handling, a SkDEBUGFAIL("Could not read
font data.") should go before the return, so that at least in debug we die early
with a more specific message. Note that this probably means removing the
SkDEBUGFAIL in SkTypeface.cpp and SkWhitelistTypeface.cpp below, since they'll
never actually happen (and their message is more generic in any event). In
general, this seems to point out the general lack of error reporting or recovery
in this whole mechanism.

[robertphillips, 2016/02/25 15:53:22]

Done.

         }
     }
+    return true;
 }
 
 void SkFontDescriptor::serialize(SkWStream* stream) {
     stream->writePackedUInt(fStyle);
 
     write_string(stream, fFamilyName, kFontFamilyName);
     write_string(stream, fFullName, kFullName);
     write_string(stream, fPostscriptName, kPostscriptName);
     if (fFontData.get()) {
         if (fFontData->getIndex()) {
@@ skipping 11 matching lines @@
 
     if (fFontData.get() && fFontData->hasStream()) {
         SkAutoTDelete<SkStreamAsset> fontData(fFontData->detachStream());
         size_t length = fontData->getLength();
         stream->writePackedUInt(length);
         stream->writeStream(fontData, length);
     } else {
         stream->writePackedUInt(0);
     }
 }