Deserialize pictures with custom image-deserializer

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 "SkImageGenerator.h"
 #include "SkPictureData.h"
 #include "SkPictureRecord.h"
@@ skipping 25 matching lines @@
 SkPictureData::SkPictureData(const SkPictureRecord& record,
                              const SkPictInfo& info)
     : fInfo(info) {
 
     this->init();
 
     fOpData = record.opData();
 
     fContentInfo.set(record.fContentInfo);
 
-    fBitmaps.reset();     // we never make bitmaps (anymore) during recording
     fPaints  = record.fPaints;
 
     fPaths.reset(record.fPaths.count());
     record.fPaths.foreach([this](const SkPath& path, int n) {
         // These indices are logically 1-based, but we need to serialize them
         // 0-based to keep the deserializing SkPictureData::getPath() working.
         fPaths[n-1] = path;
     });
 
     this->initForPlayback();
@@ skipping 71 matching lines @@
 
     for (int i = 0; i < fImageCount; i++) {
         fImageRefs[i]->unref();
     }
     delete[] fImageRefs;
 
     delete fFactoryPlayback;
 }
 
 bool SkPictureData::containsBitmaps() const {
-    if (fBitmaps.count() > 0 || fImageCount > 0) {
+    if (fBitmapImageCount > 0 || fImageCount > 0) {
         return true;
     }
     for (int i = 0; i < fPictureCount; ++i) {
         if (fPictureRefs[i]->willPlayBackBitmaps()) {
             return true;
         }
     }
     return false;
 }
 
@@ skipping 67 matching lines @@
     rec.copyToArray((SkRefCnt**)array);
 
     for (int i = 0; i < count; i++) {
         array[i]->serialize(stream);
     }
 }
 
 void SkPictureData::flattenToBuffer(SkWriteBuffer& buffer) const {
     int i, n;
 
-    // we never record bitmaps anymore, only images
-    SkASSERT(fBitmaps.count() == 0);
-
     if ((n = fPaints.count()) > 0) {
         write_tag_size(buffer, SK_PICT_PAINT_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writePaint(fPaints[i]);
         }
     }
 
     if ((n = fPaths.count()) > 0) {
         write_tag_size(buffer, SK_PICT_PATH_BUFFER_TAG, n);
         buffer.writeInt(n);
@@ skipping 115 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,
+                                   SkImageDeserializer* factory,
                                    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.
      */
@@ skipping 32 matching lines @@
                     // the default here.
                     tf = SkTypeface::MakeDefault();
                 }
                 fTFPlayback.set(i, tf.get());
             }
         } break;
         case SK_PICT_PICTURE_TAG: {
             fPictureCount = 0;
             fPictureRefs = new const SkPicture* [size];
             for (uint32_t i = 0; i < size; i++) {
-                fPictureRefs[i] = SkPicture::MakeFromStream(stream, proc, topLevelTFPlayback).release();
+                fPictureRefs[i] = SkPicture::MakeFromStream(stream, factory, topLevelTFPlayback).release();
                 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);
 
             if (!fFactoryPlayback) {
                 return false;
             }
             fFactoryPlayback->setupBuffer(buffer);
-            buffer.setBitmapDecoder(proc);
+            buffer.setImageDeserializer(factory);
 
             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;
             }
             SkDEBUGCODE(haveBuffer = true;)
         } break;
     }
     return true;    // success
 }
 
 static const SkImage* create_image_from_buffer(SkReadBuffer& buffer) {
-    return buffer.readImage();
+    return buffer.readImage().release();
+}
+
+static const SkImage* create_bitmap_image_from_buffer(SkReadBuffer& buffer) {
+    return buffer.readBitmapAsImage().release();
 }
 
 // Need a shallow wrapper to return const SkPicture* to match the other factories,
 // as SkPicture::CreateFromBuffer() returns SkPicture*
 static const SkPicture* create_picture_from_buffer(SkReadBuffer& buffer) {
     return SkPicture::MakeFromBuffer(buffer).release();
 }
 
 static const SkDrawable* create_drawable_from_buffer(SkReadBuffer& buffer) {
     return (SkDrawable*) buffer.readFlattenable(SkFlattenable::kSkDrawable_Type);
@@ skipping 28 matching lines @@
         delete[] * array;
         *array = nullptr;
         *outCount = 0;
         return false;
     }
     return true;
 }
 
 bool SkPictureData::parseBufferTag(SkReadBuffer& buffer, uint32_t tag, uint32_t size) {
     switch (tag) {
-        case SK_PICT_BITMAP_BUFFER_TAG: {
-            const int count = SkToInt(size);
-            fBitmaps.reset(count);
-            for (int i = 0; i < count; ++i) {
-                SkBitmap* bm = &fBitmaps[i];
-                if (buffer.readBitmap(bm)) {
-                    bm->setImmutable();
-                } else {
-                    return false;
-                }
+        case SK_PICT_BITMAP_BUFFER_TAG:
+            if (!new_array_from_buffer(buffer, size, &fBitmapImageRefs, &fBitmapImageCount,
+                                       create_bitmap_image_from_buffer)) {
+                return false;
             }
-        } break;
+            break;
         case SK_PICT_PAINT_BUFFER_TAG: {
             const int count = SkToInt(size);
             fPaints.reset(count);
             for (int i = 0; i < count; ++i) {
                 buffer.readPaint(&fPaints[i]);
             }
         } break;
         case SK_PICT_PATH_BUFFER_TAG:
             if (size > 0) {
                 const int count = buffer.readInt();
@@ skipping 37 matching lines @@
             break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
 SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
                                                const SkPictInfo& info,
-                                               SkPicture::InstallPixelRefProc proc,
+                                               SkImageDeserializer* factory,
                                                SkTypefacePlayback* topLevelTFPlayback) {
     SkAutoTDelete<SkPictureData> data(new SkPictureData(info));
     if (!topLevelTFPlayback) {
         topLevelTFPlayback = &data->fTFPlayback;
     }
 
-    if (!data->parseStream(stream, proc, topLevelTFPlayback)) {
+    if (!data->parseStream(stream, factory, topLevelTFPlayback)) {
         return nullptr;
     }
     return data.release();
 }
 
 SkPictureData* SkPictureData::CreateFromBuffer(SkReadBuffer& buffer,
                                                const SkPictInfo& info) {
     SkAutoTDelete<SkPictureData> data(new SkPictureData(info));
     buffer.setVersion(info.fVersion);
 
     if (!data->parseBuffer(buffer)) {
         return nullptr;
     }
     return data.release();
 }
 
 bool SkPictureData::parseStream(SkStream* stream,
-                                SkPicture::InstallPixelRefProc proc,
+                                SkImageDeserializer* factory,
                                 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, topLevelTFPlayback)) {
+        if (!this->parseStreamTag(stream, tag, size, factory, 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 26 matching lines @@
     } else {
         return this->suitableForGpuRasterization(nullptr, reason);
     }
 }
 
 bool SkPictureData::suitableForLayerOptimization() const {
     return fContentInfo.numLayers() > 0;
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////