wip for drawables

src/core/SkRecordDraw.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 "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkPatchUtils.h"
 
 void SkRecordDraw(const SkRecord& record,
                   SkCanvas* canvas,
+                  SkPicture* const drawablePicts[], int drawableCount,
                   const SkBBoxHierarchy* bbh,
                   SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     if (bbh) {
         // Draw only ops that affect pixels in the canvas's current clip.
         // The SkRecord and BBH were recorded in identity space.  This canvas
         // is not necessarily in that same space.  getClipBounds() returns us
         // this canvas' clip bounds transformed back into identity space, which
         // lets us query the BBH.
         SkRect query;
         if (!canvas->getClipBounds(&query)) {
             return;
         }
 
         SkTDArray<unsigned> ops;
         bbh->search(query, &ops);
 
-        SkRecords::Draw draw(canvas);
+        SkRecords::Draw draw(canvas, drawablePicts, drawableCount);
         for (int i = 0; i < ops.count(); i++) {
             if (callback && callback->abortDrawing()) {
                 return;
             }
             // This visit call uses the SkRecords::Draw::operator() to call
             // methods on the |canvas|, wrapped by methods defined with the
             // DRAW() macro.
             record.visit<void>(ops[i], draw);
         }
     } else {
         // Draw all ops.
-        SkRecords::Draw draw(canvas);
+        SkRecords::Draw draw(canvas, drawablePicts, drawableCount);
         for (unsigned i = 0; i < record.count(); i++) {
             if (callback && callback->abortDrawing()) {
                 return;
             }
             // This visit call uses the SkRecords::Draw::operator() to call
             // methods on the |canvas|, wrapped by methods defined with the
             // DRAW() macro.
             record.visit<void>(i, draw);
         }
     }
 }
 
 void SkRecordPartialDraw(const SkRecord& record,
                          SkCanvas* canvas,
+//                         SkPicture* const drawablePicts[], int drawableCount,
                          const SkRect& clearRect,
                          unsigned start, unsigned stop,
                          const SkMatrix& initialCTM) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     stop = SkTMin(stop, record.count());
-    SkRecords::PartialDraw draw(canvas, clearRect, initialCTM);
+    SkRecords::PartialDraw draw(canvas, NULL, 0, clearRect, initialCTM);
     for (unsigned i = start; i < stop; i++) {
         record.visit<void>(i, draw);
     }
 }
 
 namespace SkRecords {
 
 // FIXME: SkBitmaps are stateful, so we need to copy them to play back in multiple threads.
 static SkBitmap shallow_copy(const SkBitmap& bitmap) {
     return bitmap;
@@ skipping 40 matching lines @@
 DRAW(DrawRect, drawRect(r.rect, r.paint));
 DRAW(DrawSprite, drawSprite(shallow_copy(r.bitmap), r.left, r.top, r.paint));
 DRAW(DrawText, drawText(r.text, r.byteLength, r.x, r.y, r.paint));
 DRAW(DrawTextBlob, drawTextBlob(r.blob, r.x, r.y, r.paint));
 DRAW(DrawTextOnPath, drawTextOnPath(r.text, r.byteLength, r.path, r.matrix, r.paint));
 DRAW(DrawVertices, drawVertices(r.vmode, r.vertexCount, r.vertices, r.texs, r.colors,
                                 r.xmode.get(), r.indices, r.indexCount, r.paint));
 DRAW(DrawData, drawData(r.data, r.length));
 #undef DRAW
 
+template <> void Draw::draw(const DrawDrawable& r) {
+    SkASSERT(r.index >= 0);
+    SkASSERT(r.index < fDrawableCount);
+    fCanvas->drawPicture(fDrawablePicts[r.index]);
+}
+
 // This is an SkRecord visitor that fills an SkBBoxHierarchy.
 //
 // The interesting part here is how to calculate bounds for ops which don't
 // have intrinsic bounds.  What is the bounds of a Save or a Translate?
 //
 // We answer this by thinking about a particular definition of bounds: if I
 // don't execute this op, pixels in this rectangle might draw incorrectly.  So
 // the bounds of a Save, a Translate, a Restore, etc. are the union of the
 // bounds of Draw* ops that they might have an effect on.  For any given
 // Save/Restore block, the bounds of the Save, the Restore, and any other
@@ skipping 359 matching lines @@
 
         return this->adjustAndMap(dst, &op.paint);
     }
 
     Bounds bounds(const DrawTextBlob& op) const {
         SkRect dst = op.blob->bounds();
         dst.offset(op.x, op.y);
         return this->adjustAndMap(dst, &op.paint);
     }
 
+    Bounds bounds(const DrawDrawable& op) const {
+        return this->adjustAndMap(op.worstCaseBounds, NULL);
+    }
+
     static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) {
 #ifdef SK_DEBUG
         SkRect correct = *rect;
 #endif
         // crbug.com/373785 ~~> xPad = 4x yPad
         // crbug.com/424824 ~~> bump yPad from 2x text size to 2.5x
         const SkScalar yPad = 2.5f * paint.getTextSize(),
                        xPad = 4.0f * yPad;
         rect->outset(xPad, yPad);
 #ifdef SK_DEBUG
@@ skipping 230 matching lines @@
     SkRecords::CollectLayers visitor(cullRect, record, data);
 
     for (unsigned curOp = 0; curOp < record.count(); curOp++) {
         visitor.setCurrentOp(curOp);
         record.visit<void>(curOp, visitor);
     }
 
     visitor.cleanUp(bbh);
 }