Sketch splitting SkPicture into an interface and SkBigPicture.

src/gpu/GrRecordReplaceDraw.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 "GrContext.h"
 #include "GrLayerCache.h"
 #include "GrRecordReplaceDraw.h"
+#include "SkBigPicture.h"
 #include "SkCanvasPriv.h"
 #include "SkGrPixelRef.h"
 #include "SkImage.h"
 #include "SkRecordDraw.h"
 #include "SkRecords.h"
 
 static inline void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
@@ skipping 17 matching lines @@
         const SkRect src = SkRect::Make(layer->rect());
         const SkRect dst = SkRect::Make(layer->srcIR());
 
         SkASSERT(layer->offset().isZero());
 
         canvas->save();
         canvas->setMatrix(SkMatrix::I());
         canvas->drawBitmapRectToRect(bm, &src, dst, layer->paint());
         canvas->restore();
     } else {
-        canvas->drawSprite(bm, 
+        canvas->drawSprite(bm,
                            layer->srcIR().fLeft + layer->offset().fX,
                            layer->srcIR().fTop + layer->offset().fY,
                            layer->paint());
     }
 }
 
 // Used by GrRecordReplaceDraw. It intercepts nested drawPicture calls and
 // also draws them with replaced layers.
 class ReplaceDraw : public SkRecords::Draw {
 public:
     ReplaceDraw(SkCanvas* canvas, GrLayerCache* layerCache,
                 SkPicture const* const drawablePicts[], int drawableCount,
                 const SkPicture* topLevelPicture,
-                const SkPicture* picture,
+                const SkBigPicture* picture,
                 const SkMatrix& initialMatrix,
                 SkPicture::AbortCallback* callback,
                 const unsigned* opIndices, int numIndices)
         : INHERITED(canvas, drawablePicts, NULL, drawableCount)
         , fCanvas(canvas)
         , fLayerCache(layerCache)
         , fTopLevelPicture(topLevelPicture)
         , fPicture(picture)
         , fInitialMatrix(initialMatrix)
         , fCallback(callback)
         , fIndex(0)
         , fNumReplaced(0) {
         fOpIndexStack.append(numIndices, opIndices);
     }
 
     int draw() {
-        const SkBBoxHierarchy* bbh = fPicture->fBBH.get();
-        const SkRecord* record = fPicture->fRecord.get();
+        const SkBBoxHierarchy* bbh = fPicture->bbh();
+        const SkRecord* record = fPicture->record();
         if (NULL == record) {
             return 0;
         }
 
         fNumReplaced = 0;
 
         fOps.rewind();
 
         if (bbh) {
             // Draw only ops that affect pixels in the canvas's current clip.
@@ skipping 37 matching lines @@
         if (fOps.count()) {
             drawPictureOffset = fOps[fIndex];
         } else {
             drawPictureOffset = fIndex;
         }
 
         fOpIndexStack.push(drawPictureOffset);
 
         SkAutoCanvasMatrixPaint acmp(fCanvas, &dp.matrix, dp.paint, dp.picture->cullRect());
 
-        // Draw sub-pictures with the same replacement list but a different picture
-        ReplaceDraw draw(fCanvas, fLayerCache, 
-                         this->drawablePicts(), this->drawableCount(),
-                         fTopLevelPicture, dp.picture, fInitialMatrix, fCallback,
-                         fOpIndexStack.begin(), fOpIndexStack.count());
-
-        fNumReplaced += draw.draw();
+        if (const SkBigPicture* bp = dp.picture->asSkBigPicture()) {
+            // Draw sub-pictures with the same replacement list but a different picture
+            ReplaceDraw draw(fCanvas, fLayerCache,
+                             this->drawablePicts(), this->drawableCount(),
+                             fTopLevelPicture, bp, fInitialMatrix, fCallback,
+                             fOpIndexStack.begin(), fOpIndexStack.count());
+            fNumReplaced += draw.draw();
+        } else {
+            // TODO: can we assume / assert this doesn't happen?
+            dp.picture->playback(fCanvas, fCallback);
+        }
 
         fOpIndexStack.pop();
     }
     void operator()(const SkRecords::SaveLayer& sl) {
 
         // For a saveLayer command, check if it can be replaced by a drawBitmap
         // call and, if so, draw it and then update the current op index accordingly.
         unsigned startOffset;
         if (fOps.count()) {
             startOffset = fOps[fIndex];
         } else {
             startOffset = fIndex;
         }
 
         fOpIndexStack.push(startOffset);
 
         GrCachedLayer* layer = fLayerCache->findLayer(fTopLevelPicture->uniqueID(),
                                                       fInitialMatrix,
                                                       fOpIndexStack.begin(),
                                                       fOpIndexStack.count());
 
         if (layer) {
             fNumReplaced++;
 
             draw_replacement_bitmap(layer, fCanvas);
 
-            if (fPicture->fBBH.get()) {
+            if (fPicture->bbh()) {
                 while (fOps[fIndex] < layer->stop()) {
                     ++fIndex;
                 }
                 SkASSERT(fOps[fIndex] == layer->stop());
             } else {
                 fIndex = layer->stop();
             }
             fOpIndexStack.pop();
             return;
         }
 
         // This is a fail for layer hoisting
         this->INHERITED::operator()(sl);
 
         fOpIndexStack.pop();
     }
 
 private:
     SkCanvas*                 fCanvas;
     GrLayerCache*             fLayerCache;
     const SkPicture*          fTopLevelPicture;
-    const SkPicture*          fPicture;
+    const SkBigPicture*       fPicture;
     const SkMatrix            fInitialMatrix;
     SkPicture::AbortCallback* fCallback;
 
     SkTDArray<unsigned>       fOps;
     int                       fIndex;
     int                       fNumReplaced;
 
     // The op code indices of all the enclosing drawPicture and saveLayer calls
     SkTDArray<unsigned>       fOpIndexStack;
 
     typedef Draw INHERITED;
 };
 
 int GrRecordReplaceDraw(const SkPicture* picture,
                         SkCanvas* canvas,
                         GrLayerCache* layerCache,
                         const SkMatrix& initialMatrix,
                         SkPicture::AbortCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
-    // TODO: drawablePicts?
-    ReplaceDraw draw(canvas, layerCache, NULL, 0,
-                     picture, picture,
-                     initialMatrix, callback, NULL, 0);
-    return draw.draw();
+    if (const SkBigPicture* bp = picture->asSkBigPicture()) {
+        // TODO: drawablePicts?
+        ReplaceDraw draw(canvas, layerCache, NULL, 0,
+                         bp, bp,
+                         initialMatrix, callback, NULL, 0);
+        return draw.draw();
+    } else {
+        // TODO: can we assume / assert this doesn't happen?
+        picture->playback(canvas, callback);
+        return 0;
+    }
 }