Enable flattening of SkRecordedDrawable

src/core/SkPictureRecorder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBigPicture.h"
 #include "SkData.h"
 #include "SkDrawable.h"
 #include "SkLayerInfo.h"
+#include "SkPictureData.h"
+#include "SkPictureRecord.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkRecord.h"
 #include "SkRecordDraw.h"
 #include "SkRecordOpts.h"
 #include "SkRecorder.h"
 #include "SkTypes.h"
+#include "SkWriteBuffer.h"
 
 SkPictureRecorder::SkPictureRecorder() {
     fActivelyRecording = false;
     fRecorder.reset(new SkRecorder(nullptr, SkRect::MakeWH(0, 0), &fMiniRecorder));
 }
 
 SkPictureRecorder::~SkPictureRecorder() {}
 
 SkCanvas* SkPictureRecorder::beginRecording(const SkRect& cullRect,
                                             SkBBHFactory* bbhFactory /* = nullptr */,
@@ skipping 139 matching lines @@
 
         size_t subPictureBytes = 0;
         for (int i = 0; pictList && i < pictList->count(); i++) {
             subPictureBytes += SkPictureUtils::ApproximateBytesUsed(pictList->begin()[i]);
         }
         // SkBigPicture will take ownership of a ref on both fRecord and fBBH.
         // We're not willing to give up our ownership, so we must ref them for SkPicture.
         return new SkBigPicture(fBounds, SkRef(fRecord.get()), pictList, SkSafeRef(fBBH.get()),
                                 saveLayerData.release(), subPictureBytes);
     }
+
+    void flatten(SkWriteBuffer& buffer) const {
+        // Write the bounds.
+        buffer.writeRect(fBounds);
+
+        // Create an SkPictureRecord to record the draw commands.
+        SkPictInfo info;
+        SkPictureRecord pictureRecord(SkISize::Make(fBounds.width(), fBounds.height()), 0);
+
+        // If the query contains the whole picture, don't bother with the bounding box hierarchy.
+        SkRect clipBounds;
+        pictureRecord.getClipBounds(&clipBounds);
+        SkBBoxHierarchy* bbh;
+        if (clipBounds.contains(fBounds)) {
+            bbh = nullptr;
+        } else {
+            bbh = fBBH.get();
+        }
+
+        // Record the draw commands.
+        pictureRecord.beginRecording();
+        SkRecordDraw(*fRecord, &pictureRecord, nullptr, fDrawableList->begin(),
+                fDrawableList->count(), bbh, nullptr);
+        pictureRecord.endRecording();
+
+        // Flatten the recorded commands and drawables.
+        SkPictureData pictureData(pictureRecord, info, false);
+        pictureData.flatten(buffer);
+    }
+
+    const char* getTypeName() const override {
+        return "SkRecordedDrawable";
+    }
 };
 
 sk_sp<SkDrawable> SkPictureRecorder::finishRecordingAsDrawable() {
     fActivelyRecording = false;
     fRecorder->flushMiniRecorder();
     fRecorder->restoreToCount(1);  // If we were missing any restores, add them now.
 
     // TODO: delay as much of this work until just before first playback?
     SkRecordOptimize(fRecord);
 
     if (fBBH.get()) {
         SkAutoTMalloc<SkRect> bounds(fRecord->count());
         SkRecordFillBounds(fCullRect, *fRecord, bounds);
         fBBH->insert(bounds, fRecord->count());
     }
 
     sk_sp<SkDrawable> drawable =
            sk_make_sp<SkRecordedDrawable>(fRecord, fBBH, fRecorder->detachDrawableList(), fCullRect,
                                    SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag));
 
     // release our refs now, so only the drawable will be the owner.
     fRecord.reset(nullptr);
     fBBH.reset(nullptr);
 
     return drawable;
 }