Sketch splitting SkPicture into an interface and SkBigPicture.

src/core/SkRecorder.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 "SkPatchUtils.h"
 #include "SkPicture.h"
 #include "SkPictureUtils.h"
 #include "SkRecorder.h"
 
 SkDrawableList::~SkDrawableList() {
     fArray.unrefAll();
 }
 
-SkPicture::SnapshotArray* SkDrawableList::newDrawableSnapshot() {
+SkBigPicture::SnapshotArray* SkDrawableList::newDrawableSnapshot() {
     const int count = fArray.count();
     if (0 == count) {
         return NULL;
     }
     SkAutoTMalloc<const SkPicture*> pics(count);
     for (int i = 0; i < count; ++i) {
         pics[i] = fArray[i]->newPictureSnapshot();
     }
-    return SkNEW_ARGS(SkPicture::SnapshotArray, (pics.detach(), count));
+    return SkNEW_ARGS(SkBigPicture::SnapshotArray, (pics.detach(), count));
 }
 
 void SkDrawableList::append(SkDrawable* drawable) {
     *fArray.append() = SkRef(drawable);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
-SkRecorder::SkRecorder(SkRecord* record, int width, int height)
+SkRecorder::SkRecorder(SkRecord* record, int width, int height, SkMiniRecorder* mr)
     : SkCanvas(SkIRect::MakeWH(width, height), SkCanvas::kConservativeRasterClip_InitFlag)
     , fApproxBytesUsedBySubPictures(0)
-    , fRecord(record) {}
+    , fRecord(record)
+    , fMiniRecorder(mr) {}
 
-SkRecorder::SkRecorder(SkRecord* record, const SkRect& bounds)
+SkRecorder::SkRecorder(SkRecord* record, const SkRect& bounds, SkMiniRecorder* mr)
     : SkCanvas(bounds.roundOut(), SkCanvas::kConservativeRasterClip_InitFlag)
     , fApproxBytesUsedBySubPictures(0)
-    , fRecord(record) {}
+    , fRecord(record)
+    , fMiniRecorder(mr) {}
 
-void SkRecorder::reset(SkRecord* record, const SkRect& bounds) {
+void SkRecorder::reset(SkRecord* record, const SkRect& bounds, SkMiniRecorder* mr) {
     this->forgetRecord();
     fRecord = record;
     this->resetForNextPicture(bounds.roundOut());
+    fMiniRecorder = mr;
 }
 
 void SkRecorder::forgetRecord() {
     fDrawableList.reset(NULL);
     fApproxBytesUsedBySubPictures = 0;
     fRecord = NULL;
 }
 
 // To make appending to fRecord a little less verbose.
 #define APPEND(T, ...) \
         SkNEW_PLACEMENT_ARGS(fRecord->append<SkRecords::T>(), SkRecords::T, (__VA_ARGS__))
 
+#define TRY_MINIRECORDER(method, ...)                       \
+    if (fMiniRecorder) {                                    \
+        if (fMiniRecorder->method(__VA_ARGS__)) { return; } \
+        this->flushMiniRecorder();                          \
+    }
+
+
 // For methods which must call back into SkCanvas.
 #define INHERITED(method, ...) this->SkCanvas::method(__VA_ARGS__)
 
 // The structs we're creating all copy their constructor arguments.  Given the way the SkRecords
 // framework works, sometimes they happen to technically be copied twice, which is fine and elided
 // into a single copy unless the class has a non-trivial copy constructor.  For classes with
 // non-trivial copy constructors, we skip the first copy (and its destruction) by wrapping the value
 // with delay_copy(), forcing the argument to be passed by const&.
 //
 // This is used below for SkBitmap, SkPaint, SkPath, and SkRegion, which all have non-trivial copy
@@ skipping 47 matching lines @@
     memcpy(dst, src, count);
     return dst;
 }
 
 // As above, assuming and copying a terminating \0.
 template <>
 char* SkRecorder::copy(const char* src) {
     return this->copy(src, strlen(src)+1);
 }
 
+void SkRecorder::flushMiniRecorder() {
+    if (fMiniRecorder) {
+        SkMiniRecorder* mr = fMiniRecorder;
+        fMiniRecorder = nullptr;
+        mr->flushToCanvas(this);
+    }
+}
 
 void SkRecorder::onDrawPaint(const SkPaint& paint) {
     APPEND(DrawPaint, delay_copy(paint));
 }
 
 void SkRecorder::onDrawPoints(PointMode mode,
                               size_t count,
                               const SkPoint pts[],
                               const SkPaint& paint) {
     APPEND(DrawPoints, delay_copy(paint), mode, SkToUInt(count), this->copy(pts, count));
 }
 
 void SkRecorder::onDrawRect(const SkRect& rect, const SkPaint& paint) {
+    TRY_MINIRECORDER(drawRect, rect, paint);
     APPEND(DrawRect, delay_copy(paint), rect);
 }
 
 void SkRecorder::onDrawOval(const SkRect& oval, const SkPaint& paint) {
     APPEND(DrawOval, delay_copy(paint), oval);
 }
 
 void SkRecorder::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
     APPEND(DrawRRect, delay_copy(paint), rrect);
 }
 
 void SkRecorder::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) {
     APPEND(DrawDRRect, delay_copy(paint), outer, inner);
 }
 
 void SkRecorder::onDrawDrawable(SkDrawable* drawable) {
     if (!fDrawableList) {
         fDrawableList.reset(SkNEW(SkDrawableList));
     }
     fDrawableList->append(drawable);
     APPEND(DrawDrawable, drawable->getBounds(), fDrawableList->count() - 1);
 }
 
 void SkRecorder::onDrawPath(const SkPath& path, const SkPaint& paint) {
+    TRY_MINIRECORDER(drawPath, path, paint);
     APPEND(DrawPath, delay_copy(paint), delay_copy(path));
 }
 
 void SkRecorder::onDrawBitmap(const SkBitmap& bitmap,
                               SkScalar left,
                               SkScalar top,
                               const SkPaint* paint) {
     APPEND(DrawBitmap, this->copy(paint), delay_copy(bitmap), left, top);
 }
 
@@ skipping 66 matching lines @@
     APPEND(DrawTextOnPath,
            delay_copy(paint),
            this->copy((const char*)text, byteLength),
            byteLength,
            delay_copy(path),
            matrix ? *matrix : SkMatrix::I());
 }
 
 void SkRecorder::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                 const SkPaint& paint) {
+    TRY_MINIRECORDER(drawTextBlob, blob, x, y, paint);
     APPEND(DrawTextBlob, delay_copy(paint), blob, x, y);
 }
 
 void SkRecorder::onDrawPicture(const SkPicture* pic, const SkMatrix* matrix, const SkPaint* paint) {
     fApproxBytesUsedBySubPictures += SkPictureUtils::ApproximateBytesUsed(pic);
     APPEND(DrawPicture, this->copy(paint), pic, matrix ? *matrix : SkMatrix::I());
 }
 
 void SkRecorder::onDrawVertices(VertexMode vmode,
                                 int vertexCount, const SkPoint vertices[],
@@ skipping 76 matching lines @@
 }
 
 void SkRecorder::addComment(const char* key, const char* value) {
     APPEND(AddComment, this->copy(key), this->copy(value));
 }
 
 void SkRecorder::endCommentGroup() {
     APPEND(EndCommentGroup);
 }