Enable flattening of SkRecordedDrawable

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 48 matching lines @@
     const SkTDArray<const SkPicture* >& pictures = record.getPictureRefs();
     fPictureCount = pictures.count();
     if (fPictureCount > 0) {
         fPictureRefs = new const SkPicture* [fPictureCount];
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i] = pictures[i];
             fPictureRefs[i]->ref();
         }
     }
 
+    const SkTDArray<SkDrawable* >& drawables = record.getDrawableRefs();
+    fDrawableCount = drawables.count();
+    if (fDrawableCount > 0) {
+        fDrawableRefs = new SkDrawable* [fDrawableCount];
+        for (int i = 0; i < fDrawableCount; i++) {
+            fDrawableRefs[i] = drawables[i];
+            fDrawableRefs[i]->ref();
+        }
+    }
+
     // templatize to consolidate with similar picture logic?
     const SkTDArray<const SkTextBlob*>& blobs = record.getTextBlobRefs();
     fTextBlobCount = blobs.count();
     if (fTextBlobCount > 0) {
         fTextBlobRefs = new 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 = new const SkImage* [fImageCount];
         for (int i = 0; i < fImageCount; ++i) {
             fImageRefs[i] = SkRef(imgs[i]);
         }
     }
 }
 
 void SkPictureData::init() {
     fPictureRefs = nullptr;
     fPictureCount = 0;
+    fDrawableRefs = nullptr;
+    fDrawableCount = 0;
     fTextBlobRefs = nullptr;
     fTextBlobCount = 0;
     fImageRefs = nullptr;
     fImageCount = 0;
     fFactoryPlayback = nullptr;
 }
 
 SkPictureData::~SkPictureData() {
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
     delete[] fPictureRefs;
 
+    for (int i = 0; i < fDrawableCount; i++) {
+        fDrawableRefs[i]->unref();
+    }
+    if (fDrawableCount > 0) {
+        SkASSERT(fDrawableRefs);
+        delete[] fDrawableRefs;
+    }
+
     for (int i = 0; i < fTextBlobCount; i++) {
         fTextBlobRefs[i]->unref();
     }
     delete[] fTextBlobRefs;
 
     for (int i = 0; i < fImageCount; i++) {
         fImageRefs[i]->unref();
     }
     delete[] fImageRefs;
 
@@ skipping 184 matching lines @@
     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++) {
             fPictureRefs[i]->flatten(buffer);
         }
     }
 
+    if (fDrawableCount > 0) {
+        write_tag_size(buffer, SK_PICT_DRAWABLE_TAG, fDrawableCount);
+        for (int i = 0; i < fDrawableCount; i++) {
+            buffer.writeFlattenable(fDrawableRefs[i]);
+        }
+    }
+
     // Write this picture playback's data into a writebuffer
     this->flattenToBuffer(buffer);
     buffer.write32(SK_PICT_EOF_TAG);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Return the corresponding SkReadBuffer flags, given a set of
  *  SkPictInfo flags.
@@ skipping 124 matching lines @@
 static const SkImage* create_image_from_buffer(SkReadBuffer& buffer) {
     return buffer.readImage();
 }
 
 // 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);
+}
+
 template <typename T>
 bool new_array_from_buffer(SkReadBuffer& buffer, uint32_t inCount,
                            const T*** array, int* outCount, const T* (*factory)(SkReadBuffer&)) {
     if (!buffer.validate((0 == *outCount) && (nullptr == *array))) {
         return false;
     }
     if (0 == inCount) {
         return true;
     }
     *outCount = inCount;
@@ skipping 70 matching lines @@
             }
             SkASSERT(nullptr == fOpData);
             fOpData = std::move(data);
         } break;
         case SK_PICT_PICTURE_TAG:
             if (!new_array_from_buffer(buffer, size, &fPictureRefs, &fPictureCount,
                                        create_picture_from_buffer)) {
                 return false;
             }
             break;
+        case SK_PICT_DRAWABLE_TAG:
+            if (!new_array_from_buffer(buffer, size, (const SkDrawable***)&fDrawableRefs,
+                                       &fDrawableCount, create_drawable_from_buffer)) {
+                return false;
+            }
+            break;
         default:
             // The tag was invalid.
             return false;
     }
     return true;    // success
 }
 
 SkPictureData* SkPictureData::CreateFromStream(SkStream* stream,
                                                const SkPictInfo& info,
                                                SkPicture::InstallPixelRefProc proc,
@@ skipping 70 matching lines @@
     } else {
         return this->suitableForGpuRasterization(nullptr, reason);
     }
 }
 
 bool SkPictureData::suitableForLayerOptimization() const {
     return fContentInfo.numLayers() > 0;
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////