Support serialization in SkRecord-backed SkPictures.

src/core/SkPicture.cpp

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPictureFlat.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
+#include "SkPictureRecorder.h"
 
 #include "SkBBHFactory.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkChunkAlloc.h"
 #include "SkDrawPictureCallback.h"
 #include "SkPaintPriv.h"
 #include "SkPicture.h"
 #include "SkRegion.h"
 #include "SkStream.h"
@@ skipping 126 matching lines @@
 }
 
 // The simplest / safest way to copy an SkRecord is to replay it into a new one.
 static SkRecord* copy(const SkRecord& src, int width, int height) {
     SkRecord* dst = SkNEW(SkRecord);
     SkRecorder recorder(dst, width, height);
     SkRecordDraw(src, &recorder);
     return dst;
 }
 
+// Create an SkPicturePlayback-backed SkPicture from an SkRecord.
+// This for compatibility with serialization code only.  This is not cheap.
+static SkPicture* backport(const SkRecord& src, int width, int height) {
+    SkPictureRecorder recorder;
+    SkRecordDraw(src, recorder.beginRecording(width, height));
+    return recorder.endRecording();
+}
+
 // fRecord OK
 SkPicture::SkPicture(const SkPicture& src) : INHERITED() {
     this->needsNewGenID();
     fWidth = src.fWidth;
     fHeight = src.fHeight;
 
     if (NULL != src.fPlayback.get()) {
         fPlayback.reset(SkNEW_ARGS(SkPicturePlayback, (*src.fPlayback)));
         fUniqueID = src.uniqueID();  // need to call method to ensure != 0
     }
@@ skipping 260 matching lines @@
     info->fHeight = fHeight;
     info->fFlags = SkPictInfo::kCrossProcess_Flag;
     // TODO: remove this flag, since we're always float (now)
     info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
 
     if (8 == sizeof(void*)) {
         info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
     }
 }
 
-// fRecord TODO
+// fRecord OK
 void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
+    const SkPicturePlayback* playback = fPlayback.get();
+
+    // If we're a new-format picture, backport to old format for serialization.
+    SkAutoTDelete<SkPicture> oldFormat;
+    if (NULL == playback && NULL != fRecord.get()) {
+        oldFormat.reset(backport(*fRecord, fWidth, fHeight));
+        playback = oldFormat->fPlayback.get();
+        SkASSERT(NULL != playback);
+    }
+
     SkPictInfo info;
     this->createHeader(&info);
     stream->write(&info, sizeof(info));
 
-    if (NULL != fPlayback.get()) {
+    if (NULL != playback) {
         stream->writeBool(true);
-        fPlayback->serialize(stream, encoder);
+        playback->serialize(stream, encoder);
     } else {
         stream->writeBool(false);
     }
 }
 
 // fRecord OK
 void SkPicture::WriteTagSize(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
     buffer.writeUInt(tag);
     buffer.writeUInt(SkToU32(size));
 }
 
 // fRecord OK
 void SkPicture::WriteTagSize(SkWStream* stream, uint32_t tag,  size_t size) {
     stream->write32(tag);
     stream->write32(SkToU32(size));
 }
 
-// fRecord TODO
+// fRecord OK
 void SkPicture::flatten(SkWriteBuffer& buffer) const {
+    const SkPicturePlayback* playback = fPlayback.get();
+
+    // If we're a new-format picture, backport to old format for serialization.
+    SkAutoTDelete<SkPicture> oldFormat;
+    if (NULL == playback && NULL != fRecord.get()) {
+        oldFormat.reset(backport(*fRecord, fWidth, fHeight));
+        playback = oldFormat->fPlayback.get();
+        SkASSERT(NULL != playback);
+    }
+
     SkPictInfo info;
     this->createHeader(&info);
     buffer.writeByteArray(&info, sizeof(info));
 
-    if (NULL != fPlayback.get()) {
+    if (NULL != playback) {
         buffer.writeBool(true);
-        fPlayback->flatten(buffer);
+        playback->flatten(buffer);
     } else {
         buffer.writeBool(false);
     }
 }
 
 #if SK_SUPPORT_GPU
 // fRecord TODO
 bool SkPicture::suitableForGpuRasterization(GrContext* context, const char **reason) const {
     if (NULL == fPlayback.get()) {
         if (NULL != reason) {
@@ skipping 44 matching lines @@
     return fUniqueID;
 }
 
 // fRecord OK
 SkPicture::SkPicture(int width, int height, SkRecord* record)
     : fWidth(width)
     , fHeight(height)
     , fRecord(record) {
     this->needsNewGenID();
 }