option to return drawable from recording

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 "SkCanvasDrawable.h"
 #include "SkData.h"
 #include "SkLayerInfo.h"
 #include "SkPictureRecorder.h"
 #include "SkRecord.h"
 #include "SkRecordDraw.h"
 #include "SkRecorder.h"
 #include "SkRecordOpts.h"
 #include "SkTypes.h"
 
 SkPictureRecorder::SkPictureRecorder() {}
@@ skipping 14 matching lines @@
     fRecord.reset(SkNEW(SkRecord));
     fRecorder.reset(SkNEW_ARGS(SkRecorder, (fRecord.get(), cullRect)));
     return this->getRecordingCanvas();
 }
 
 SkCanvas* SkPictureRecorder::getRecordingCanvas() {
     return fRecorder.get();
 }
 
 SkPicture* SkPictureRecorder::endRecording() {
+#if 0
     // TODO: delay as much of this work until just before first playback?
     SkRecordOptimize(fRecord);
 
     SkAutoTUnref<SkLayerInfo> saveLayerData;
 
     if (fBBH && (fFlags & kComputeSaveLayerInfo_RecordFlag)) {
         SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
 
         saveLayerData.reset(SkNEW_ARGS(SkLayerInfo, (key)));
     }
@@ skipping 12 matching lines @@
     SkAutoTDelete<SkPicture::SnapshotArray> drawablePicts(
             fRecorder->newDrawableSnapshot(factory, recordFlags));
     SkPicture* pict = SkNEW_ARGS(SkPicture, (fCullRect, fRecord.detach(),
                                              drawablePicts.detach(), fBBH.get()));
 
     if (saveLayerData) {
         pict->EXPERIMENTAL_addAccelData(saveLayerData);
     }
 
     return pict;
+#else
+    SkAutoTUnref<SkCanvasDrawable> drawable(this->EXPERIMENTAL_endRecordingAsDrawable());
+    return drawable->newPictureSnapshot();
+#endif
 }
 
 void SkPictureRecorder::partialReplay(SkCanvas* canvas) const {
     if (NULL == canvas) {
         return;
     }
 
     int drawableCount = 0;
-    SkRecordDraw(*fRecord, canvas, NULL, drawableCount, NULL/*bbh*/, NULL/*callback*/);
+    SkRecordDraw(*fRecord, canvas, NULL, NULL, drawableCount, NULL/*bbh*/, NULL/*callback*/);
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkRecordedDrawable : public SkCanvasDrawable {
+    SkAutoTUnref<SkRecord>              fRecord;
+    SkAutoTUnref<SkBBoxHierarchy>       fBBH;
+    SkAutoTDelete<SkCanvasDrawableList> fDrawableList;
+    const SkRect                        fBounds;
+    const bool                          fDoSaveLayerInfo;
+
+public:
+    SkRecordedDrawable(SkRecord* record, SkBBoxHierarchy* bbh, SkCanvasDrawableList* drawableList,
+                       const SkRect& bounds, bool doSaveLayerInfo)
+        : fRecord(SkRef(record))
+        , fBBH(SkSafeRef(bbh))
+        , fDrawableList(drawableList)   // we take ownership
+        , fBounds(bounds)
+        , fDoSaveLayerInfo(doSaveLayerInfo)
+    {}
+
+protected:

[robertphillips, 2014/11/24 15:42:02]

one line ?

[reed1, 2014/11/24 17:10:48]

Done.

+    SkRect onGetBounds() SK_OVERRIDE {
+        return fBounds;
+    }
+
+    void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+        SkCanvasDrawable* const* drawables = NULL;
+        int drawableCount = 0;
+        if (fDrawableList) {
+            drawables = fDrawableList->begin();
+            drawableCount = fDrawableList->count();
+        }
+        SkRecordDraw(*fRecord, canvas, NULL, drawables, drawableCount, fBBH, NULL/*callback*/);
+    }
+
+    SkPicture* onNewPictureSnapshot() SK_OVERRIDE {
+        SkPicture::SnapshotArray* pictList = NULL;
+        if (fDrawableList) {

[robertphillips, 2014/11/24 15:42:02]

Are we going to plumb down the BBH and SVI preferences here ?

[reed1, 2014/11/24 17:10:48]

No idea -- will leave as a TODO for now.

[mtklein, 2014/11/24 17:29:41]

Seems like if we're going to plumb BBHs further, we'll need to either hang on to
the BBH factory, or add something like
  SkBBH* newOfSameType() const = 0;
to the SkBBH interface.

[reed1, 2014/11/24 19:12:07]

Agreed, though in the lastest patch I added a TODO to carry out that
investigation.

+            pictList = fDrawableList->newDrawableSnapshot();
+        }
+
+        SkAutoTUnref<SkLayerInfo> saveLayerData;
+
+        if (fBBH && fDoSaveLayerInfo) {
+            SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
+
+            saveLayerData.reset(SkNEW_ARGS(SkLayerInfo, (key)));
+
+            SkBBoxHierarchy* bbh = NULL;    // we've already computed fBBH (received in constructor)
+            // TODO: update saveLayer info computation to reuse the already computed
+            // bounds in 'fBBH'

[mtklein, 2014/11/24 17:29:41]

fBBH doesn't necessarily contain those bounds any more, nor necessarily have an
efficient way of mapping opID to bounds, only bounds to opIDs.

Sounds like we want to explicitly fill a bounds array, then use that to fill in
the BBH and to help the SaveLayer computation?  This is what happens anyway...
just need to reorganize the interfaces.

There's a small wrinkle that BBHs as written optionally can take ownership of
their input bounds array.  None do, so we can drop that if it makes things
easier.

[reed1, 2014/11/24 19:12:07]

Is this something that should be figured out now, or can it be done after this
CL lands?

+            SkRecordComputeLayers(fBounds, *fRecord, pictList, bbh, saveLayerData);
+        }
+
+        SkPicture* pict = SkNEW_ARGS(SkPicture, (fBounds, fRecord, pictList, fBBH));
+
+        if (saveLayerData) {
+            pict->EXPERIMENTAL_addAccelData(saveLayerData);
+        }
+        return pict;
+    }
+};
+
+SkCanvasDrawable* SkPictureRecorder::EXPERIMENTAL_endRecordingAsDrawable() {
+    // TODO: delay as much of this work until just before first playback?
+    SkRecordOptimize(fRecord);
+
+    if (fBBH.get()) {
+        SkRecordFillBounds(fCullRect, *fRecord, fBBH.get());
+    }
+
+    return SkNEW_ARGS(SkRecordedDrawable, (fRecord, fBBH, fRecorder->detachDrawableList(),
+                                           fCullRect,
+                                           SkToBool(fFlags & kComputeSaveLayerInfo_RecordFlag)));
+}