Deduplicate typefaces across sub-pictures

src/core/SkPictureData.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include <new>
 #include "SkPictureData.h"
 #include "SkPictureRecord.h"
 #include "SkReadBuffer.h"
@@ skipping 50 matching lines @@
 
     // templatize to consolidate with similar picture logic?
     const SkTDArray<const SkTextBlob*>& blobs = record.getTextBlobRefs();
     fTextBlobCount = blobs.count();
     if (fTextBlobCount > 0) {
         fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount);
         for (int i = 0; i < fTextBlobCount; ++i) {
             fTextBlobRefs[i] = SkRef(blobs[i]);
         }
     }
-        
+
     const SkTDArray<const SkImage*>& imgs = record.getImageRefs();
     fImageCount = imgs.count();
     if (fImageCount > 0) {
         fImageRefs = SkNEW_ARRAY(const SkImage*, fImageCount);
         for (int i = 0; i < fImageCount; ++i) {
             fImageRefs[i] = SkRef(imgs[i]);
         }
     }
 }
 
@@ skipping 13 matching lines @@
 
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
     SkDELETE_ARRAY(fPictureRefs);
 
     for (int i = 0; i < fTextBlobCount; i++) {
         fTextBlobRefs[i]->unref();
     }
     SkDELETE_ARRAY(fTextBlobRefs);
-    
+
     for (int i = 0; i < fImageCount; i++) {
         fImageRefs[i]->unref();
     }
     SkDELETE_ARRAY(fImageRefs);
-    
+
     SkDELETE(fFactoryPlayback);
 }
 
 bool SkPictureData::containsBitmaps() const {
     if (fBitmaps.count() > 0 || fImageCount > 0) {
         return true;
     }
     for (int i = 0; i < fPictureCount; ++i) {
         if (fPictureRefs[i]->willPlayBackBitmaps()) {
             return true;
@@ skipping 105 matching lines @@
             buffer.writePath(fPaths[i]);
         }
     }
 
     if (fTextBlobCount > 0) {
         write_tag_size(buffer, SK_PICT_TEXTBLOB_BUFFER_TAG, fTextBlobCount);
         for (i = 0; i  < fTextBlobCount; ++i) {
             fTextBlobRefs[i]->flatten(buffer);
         }
     }
-    
+
     if (fImageCount > 0) {
         write_tag_size(buffer, SK_PICT_IMAGE_BUFFER_TAG, fImageCount);
         for (i = 0; i  < fImageCount; ++i) {
             buffer.writeImage(fImageRefs[i]);
         }
     }
 }
 
 void SkPictureData::serialize(SkWStream* stream,
-                              SkPixelSerializer* pixelSerializer) const {
+                              SkPixelSerializer* pixelSerializer,
+                              SkRefCntSet* topLevelTypeFaceSet) const {
+    // This can happen at pretty much any time, so might as well do it first.
     write_tag_size(stream, SK_PICT_READER_TAG, fOpData->size());
     stream->write(fOpData->bytes(), fOpData->size());
 
+    // We serialize all typefaces into the typeface section of the top-level picture.
+    SkRefCntSet localTypefaceSet;
+    SkRefCntSet* typefaceSet = topLevelTypeFaceSet ? topLevelTypeFaceSet : &localTypefaceSet;
+
+    // We delay serializing the bulk of our data until after we've serialized
+    // factories and typefaces by first serializing to an in-memory write buffer.
+    SkFactorySet factSet;  // buffer refs factSet, so factSet must come first.
+    SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag);
+    buffer.setFactoryRecorder(&factSet);
+    buffer.setPixelSerializer(pixelSerializer);
+    buffer.setTypefaceRecorder(typefaceSet);
+    this->flattenToBuffer(buffer);
+
+    // Dummy serialize our sub-pictures for the side effect of filling
+    // typefaceSet with typefaces from sub-pictures.
+    struct DevNull: public SkWStream {
+        DevNull() : fBytesWritten(0) {}
+        size_t fBytesWritten;
+        bool write(const void*, size_t size) override { fBytesWritten += size; return true; }
+        size_t bytesWritten() const override { return fBytesWritten; }
+    } devnull;
+    for (int i = 0; i < fPictureCount; i++) {
+        fPictureRefs[i]->serialize(&devnull, pixelSerializer, typefaceSet);
+    }
+
+    // We need to write factories before we write the buffer.
+    // We need to write typefaces before we write the buffer or any sub-picture.
+    WriteFactories(stream, factSet);
+    if (typefaceSet == &localTypefaceSet) {
+        WriteTypefaces(stream, *typefaceSet);
+    }
+
+    // Write the buffer.
+    write_tag_size(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
+    buffer.writeToStream(stream);
+
+    // Write sub-pictures by calling serialize again.
     if (fPictureCount > 0) {
         write_tag_size(stream, SK_PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
-            fPictureRefs[i]->serialize(stream, pixelSerializer);
+            fPictureRefs[i]->serialize(stream, pixelSerializer, typefaceSet);
         }
     }
 
-    // Write some of our data into a writebuffer, and then serialize that
-    // into our stream
-    {
-        SkRefCntSet  typefaceSet;
-        SkFactorySet factSet;
-
-        SkWriteBuffer buffer(SkWriteBuffer::kCrossProcess_Flag);
-        buffer.setTypefaceRecorder(&typefaceSet);
-        buffer.setFactoryRecorder(&factSet);
-        buffer.setPixelSerializer(pixelSerializer);
-
-        this->flattenToBuffer(buffer);
-
-        // We have to write these two sets into the stream *before* we write
-        // the buffer, since parsing that buffer will require that we already
-        // have these sets available to use.
-        WriteFactories(stream, factSet);
-        WriteTypefaces(stream, typefaceSet);
-
-        write_tag_size(stream, SK_PICT_BUFFER_SIZE_TAG, buffer.bytesWritten());
-        buffer.writeToStream(stream);
-    }
-
     stream->write32(SK_PICT_EOF_TAG);
 }
 
 void SkPictureData::flatten(SkWriteBuffer& buffer) const {
     write_tag_size(buffer, SK_PICT_READER_TAG, fOpData->size());
     buffer.writeByteArray(fOpData->bytes(), fOpData->size());
 
     if (fPictureCount > 0) {
         write_tag_size(buffer, SK_PICT_PICTURE_TAG, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
@@ skipping 27 matching lines @@
         if (pictInfoFlags & gSD[i].fSrc) {
             rbMask |= gSD[i].fDst;
         }
     }
     return rbMask;
 }
 
 bool SkPictureData::parseStreamTag(SkStream* stream,
                                    uint32_t tag,
                                    uint32_t size,
-                                   SkPicture::InstallPixelRefProc proc) {
+                                   SkPicture::InstallPixelRefProc proc,
+                                   SkTypefacePlayback* topLevelTFPlayback) {
     /*
      *  By the time we encounter BUFFER_SIZE_TAG, we need to have already seen
      *  its dependents: FACTORY_TAG and TYPEFACE_TAG. These two are not required
      *  but if they are present, they need to have been seen before the buffer.
      *
      *  We assert that if/when we see either of these, that we have not yet seen
      *  the buffer tag, because if we have, then its too-late to deal with the
      *  factories or typefaces.
      */
     SkDEBUGCODE(bool haveBuffer = false;)
@@ skipping 31 matching lines @@
                     // the default here.
                     tf.reset(SkTypeface::RefDefault());
                 }
                 fTFPlayback.set(i, tf);
             }
         } break;
         case SK_PICT_PICTURE_TAG: {
             fPictureCount = 0;
             fPictureRefs = SkNEW_ARRAY(const SkPicture*, size);
             for (uint32_t i = 0; i < size; i++) {
-                fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc);
+                fPictureRefs[i] = SkPicture::CreateFromStream(stream, proc, topLevelTFPlayback);
                 if (!fPictureRefs[i]) {
                     return false;
                 }
                 fPictureCount++;
             }
         } break;
         case SK_PICT_BUFFER_SIZE_TAG: {
             SkAutoMalloc storage(size);
             if (stream->read(storage.get(), size) != size) {
                 return false;
             }
 
             /* Should we use SkValidatingReadBuffer instead? */
             SkReadBuffer buffer(storage.get(), size);
             buffer.setFlags(pictInfoFlagsToReadBufferFlags(fInfo.fFlags));
             buffer.setVersion(fInfo.fVersion);
 
             fFactoryPlayback->setupBuffer(buffer);
-            fTFPlayback.setupBuffer(buffer);
             buffer.setBitmapDecoder(proc);
 
+            if (fTFPlayback.count() > 0) {
+                // .skp files <= v43 have typefaces serialized with each sub picture.
+                fTFPlayback.setupBuffer(buffer);
+            } else {
+                // Newer .skp files serialize all typefaces with the top picture.
+                topLevelTFPlayback->setupBuffer(buffer);
+            }
+
             while (!buffer.eof() && buffer.isValid()) {
                 tag = buffer.readUInt();
                 size = buffer.readUInt();
                 if (!this->parseBufferTag(buffer, tag, size)) {
                     return false;
                 }
             }
             if (!buffer.isValid()) {
                 return false;
             }
@@ skipping 121 matching lines @@
             break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
 SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
                                                const SkPictInfo& info,
-                                               SkPicture::InstallPixelRefProc proc) {
+                                               SkPicture::InstallPixelRefProc proc,
+                                               SkTypefacePlayback* topLevelTFPlayback) {
     SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
+    if (!topLevelTFPlayback) {
+        topLevelTFPlayback = &data->fTFPlayback;
+    }
 
-    if (!data->parseStream(stream, proc)) {
+    if (!data->parseStream(stream, proc, topLevelTFPlayback)) {
         return NULL;
     }
     return data.detach();
 }
 
 SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
                                                const SkPictInfo& info) {
     SkAutoTDelete<SkPictureData> data(SkNEW_ARGS(SkPictureData, (info)));
     buffer.setVersion(info.fVersion);
 
     if (!data->parseBuffer(buffer)) {
         return NULL;
     }
     return data.detach();
 }
 
 bool SkPictureData::parseStream(SkStream* stream,
-                                SkPicture::InstallPixelRefProc proc) {
+                                SkPicture::InstallPixelRefProc proc,
+                                SkTypefacePlayback* topLevelTFPlayback) {
     for (;;) {
         uint32_t tag = stream->readU32();
         if (SK_PICT_EOF_TAG == tag) {
             break;
         }
 
         uint32_t size = stream->readU32();
-        if (!this->parseStreamTag(stream, tag, size, proc)) {
+        if (!this->parseStreamTag(stream, tag, size, proc, topLevelTFPlayback)) {
             return false; // we're invalid
         }
     }
     return true;
 }
 
 bool SkPictureData::parseBuffer(SkReadBuffer& buffer) {
     for (;;) {
         uint32_t tag = buffer.readUInt();
         if (SK_PICT_EOF_TAG == tag) {
@@ skipping 28 matching lines @@
     }
 }
 
 bool SkPictureData::suitableForLayerOptimization() const {
     return fContentInfo.numLayers() > 0;
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////