add replay entry point to SkPictureRecorder for Android

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 898 matching lines @@
 
 #endif
 
 static void set_canvas_to_save_count_4(SkCanvas* canvas) {
     canvas->restoreToCount(1);
     canvas->save();
     canvas->save();
     canvas->save();
 }
 
+#ifdef SK_BUILD_FOR_ANDROID
+/**
+ * A canvas that records the number of saves, saveLayers and restores.
+ */
+class SaveCountingCanvas : public SkCanvas {
+public:
+    SaveCountingCanvas(int width, int height)
+        : INHERITED(width, height)
+        , fSaveCount(0)
+        , fSaveLayerCount(0)
+        , fRestoreCount(0){
+    }
+
+    virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds, const SkPaint* paint,
+                                            SaveFlags flags) SK_OVERRIDE {
+        ++fSaveLayerCount;
+        return this->INHERITED::willSaveLayer(bounds, paint, flags);
+    }
+
+    virtual void willSave(SaveFlags flags) SK_OVERRIDE {
+        ++fSaveCount;
+        this->INHERITED::willSave(flags);
+    }
+
+    virtual void willRestore() SK_OVERRIDE {
+        ++fRestoreCount;
+        this->INHERITED::willRestore();
+    }
+
+    unsigned int getSaveCount() const { return fSaveCount; }
+    unsigned int getSaveLayerCount() const { return fSaveLayerCount; }
+    unsigned int getRestoreCount() const { return fRestoreCount; }
+
+private:
+    unsigned int fSaveCount;
+    unsigned int fSaveLayerCount;
+    unsigned int fRestoreCount;
+
+    typedef SkCanvas INHERITED;
+};
+
+void check_save_state(skiatest::Reporter* reporter, SkPicture* picture, 
+                      int numSaves, int numSaveLayers, int numRestores) {
+    SaveCountingCanvas canvas(picture->width(), picture->height());
+
+    picture->draw(&canvas);
+
+    REPORTER_ASSERT(reporter, numSaves == canvas.getSaveCount());
+    REPORTER_ASSERT(reporter, numSaveLayers == canvas.getSaveLayerCount());
+    REPORTER_ASSERT(reporter, numRestores == canvas.getRestoreCount());
+}
+
+// This class exists so SkPicture can friend it and give it access to
+// the 'partialReplay' method.
+class SkPictureRecorderReplayTester {
+public:
+    static SkPicture* Copy(SkPictureRecorder* recorder) {
+        SkPictureRecorder recorder2;
+
+        SkCanvas* canvas = recorder2.beginRecording(10, 10, NULL, 0);
+
+        recorder->partialReplay(canvas);
+
+        return recorder2.endRecording();
+    }
+};
+
+// Test out SkPictureRecorder::partialReplay
+DEF_TEST(PictureRecorder_replay, reporter) {
+    // check save/saveLayer state
+    {
+        SkPictureRecorder recorder;
+
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
+
+        canvas->saveLayer(NULL, NULL);
+
+        SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
+
+        // The extra save and restore comes from the Copy process.
+        check_save_state(reporter, copy, 2, 1, 3);
+
+        canvas->saveLayer(NULL, NULL);
+
+        SkAutoTUnref<SkPicture> final(recorder.endRecording());
+
+        check_save_state(reporter, final, 1, 2, 3);
+
+        // The copy shouldn't pick up any operations added after it was made
+        check_save_state(reporter, copy, 2, 1, 3);
+    }
+
+    // (partially) check leakage of draw ops
+    {
+        SkPictureRecorder recorder;
+
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
+
+        SkRect r = SkRect::MakeWH(5, 5);
+        SkPaint p;
+
+        canvas->drawRect(r, p);
+
+        SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
+
+        REPORTER_ASSERT(reporter, !copy->willPlayBackBitmaps());
+
+        SkBitmap bm;
+        make_bm(&bm, 10, 10, SK_ColorRED, true);
+
+        r.offset(5.0f, 5.0f);
+        canvas->drawBitmapRectToRect(bm, NULL, r);
+
+        SkAutoTUnref<SkPicture> final(recorder.endRecording());
+        REPORTER_ASSERT(reporter, final->willPlayBackBitmaps());
+
+        REPORTER_ASSERT(reporter, copy->uniqueID() != final->uniqueID());
+
+        // The snapshot shouldn't pick up any operations added after it was made
+        REPORTER_ASSERT(reporter, !copy->willPlayBackBitmaps());
+    }
+}
+#endif
+
 static void test_unbalanced_save_restores(skiatest::Reporter* reporter) {
     SkCanvas testCanvas(100, 100);
     set_canvas_to_save_count_4(&testCanvas);
 
     REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
 
     SkPaint paint;
     SkRect rect = SkRect::MakeLTRB(-10000000, -10000000, 10000000, 10000000);
 
     SkPictureRecorder recorder;
@@ skipping 51 matching lines @@
     defined(SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES)
     set_canvas_to_save_count_4(&testCanvas);
 
     // Due to "fake" endRecording, the old SkPicture recording interface
     // allowed unbalanced saves/restores to leak out. This sub-test checks
     // that the situation has been remedied.
     {
         SkPicture p;
 
         SkCanvas* canvas = p.beginRecording(100, 100);
         for (int i = 0; i < 4; ++i) {

[scroggo, 2014/05/27 14:50:03]

It looks like this is slightly different from set_canvas_to_save_count_4. Is
there a reason for that?

[robertphillips, 2014/05/27 17:23:39]

In this instance the restoreToCount in set_canvas_to_save_count_4 would be a bit
misleading.

            canvas->save();
         }
         SkRect r = SkRect::MakeWH(50, 50);
         SkPaint paint;
         canvas->drawRect(r, paint);
 
         // Copying a mid-recording picture could result in unbalanced saves/restores

[scroggo, 2014/05/27 14:50:03]

Instead of "could result in", don't we really mean "must not result in"?

[robertphillips, 2014/05/27 17:23:39]

Done.

         SkPicture p2(p);
 
         testCanvas.drawPicture(p2);
         REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
         set_canvas_to_save_count_4(&testCanvas);

[scroggo, 2014/05/27 14:50:03]

Is this in case the prior assert failed?

[robertphillips, 2014/05/27 17:23:39]

Yes. I extended this test case to check the "fake" endRecording paths and it was
set up to always restore to a known state between sub-tests.

 
         // Cloning a mid-recording picture could result in unbalanced saves/restores
         SkAutoTUnref<SkPicture> p3(p.clone());
         testCanvas.drawPicture(*p3);
         REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
         set_canvas_to_save_count_4(&testCanvas);
 
         // Serializing a mid-recording picture could result in unbalanced saves/restores
         SkDynamicMemoryWStream wStream;
         p.serialize(&wStream);
@@ skipping 279 matching lines @@
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
 }
 
 /**
  * A canvas that records the number of clip commands.
  */
 class ClipCountingCanvas : public SkCanvas {
 public:
-    explicit ClipCountingCanvas(int width, int height)
+    ClipCountingCanvas(int width, int height)
         : INHERITED(width, height)
         , fClipCount(0){
     }
 
     virtual void onClipRect(const SkRect& r,
                             SkRegion::Op op,
                             ClipEdgeStyle edgeStyle) SK_OVERRIDE {
         fClipCount += 1;
         this->INHERITED::onClipRect(r, op, edgeStyle);
     }
@@ skipping 187 matching lines @@
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 }
 
 DEF_TEST(Canvas_EmptyBitmap, r) {
     SkBitmap dst;
     dst.allocN32Pixels(10, 10);
     SkCanvas canvas(dst);
 
     test_draw_bitmaps(&canvas);
 }