split SkPictureRecorder out of SkPicture

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 "SkCanvas.h"
 #include "SkColorPriv.h"
@@ skipping 283 matching lines @@
                          indices, 6, paint);
     *usedPixRefs->append() = bm.pixelRef();
 }
 
 // Return a picture with the bitmaps drawn at the specified positions.
 static SkPicture* record_bitmaps(const SkBitmap bm[],
                                  const SkPoint pos[],
                                  SkTDArray<SkPixelRef*> analytic[],
                                  int count,
                                  DrawBitmapProc proc) {
-    SkPicture* pic = new SkPicture;
-    SkCanvas* canvas = pic->beginRecording(1000, 1000);
+    SkPictureRecorder recorder;
+    SkCanvas* canvas = recorder.beginRecording(1000, 1000);
     for (int i = 0; i < count; ++i) {
         analytic[i].rewind();
         canvas->save();
         SkRect clipRect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY,
                                            SkIntToScalar(bm[i].width()),
                                            SkIntToScalar(bm[i].height()));
         canvas->clipRect(clipRect, SkRegion::kIntersect_Op);
         proc(canvas, bm[i], bm[count+i], pos[i], &analytic[i]);
         canvas->restore();
     }
-    pic->endRecording();
-    return pic;
+    return recorder.endRecording();
 }
 
 static void rand_rect(SkRect* rect, SkRandom& rand, SkScalar W, SkScalar H) {
     rect->fLeft   = rand.nextRangeScalar(-W, 2*W);
     rect->fTop    = rand.nextRangeScalar(-H, 2*H);
     rect->fRight  = rect->fLeft + rand.nextRangeScalar(0, W);
     rect->fBottom = rect->fTop + rand.nextRangeScalar(0, H);
 
     // we integralize rect to make our tests more predictable, since Gather is
     // a little sloppy.
@@ skipping 322 matching lines @@
                 REPORTER_ASSERT(reporter, -1 != gatheredRefs.find(fromAnalytic[i]));
             }
         }
     }
 }
 
 #ifdef SK_DEBUG
 // Ensure that deleting SkPicturePlayback does not assert. Asserts only fire in debug mode, so only
 // run in debug mode.
 static void test_deleting_empty_playback() {
-    SkPicture picture;
+    SkPictureRecorder recorder;
     // Creates an SkPictureRecord
-    picture.beginRecording(0, 0);
+    recorder.beginRecording(0, 0);
     // Turns that into an SkPicturePlayback
-    picture.endRecording();
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     // Deletes the old SkPicturePlayback, and creates a new SkPictureRecord
-    picture.beginRecording(0, 0);
+    recorder.beginRecording(0, 0);
 }
 
 // Ensure that serializing an empty picture does not assert. Likewise only runs in debug mode.
 static void test_serializing_empty_picture() {
-    SkPicture picture;
-    picture.beginRecording(0, 0);
-    picture.endRecording();
+    SkPictureRecorder recorder;
+    recorder.beginRecording(0, 0);
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     SkDynamicMemoryWStream stream;
-    picture.serialize(&stream);
+    picture->serialize(&stream);
 }
 #endif
 
 static void rand_op(SkCanvas* canvas, SkRandom& rand) {
     SkPaint paint;
     SkRect rect = SkRect::MakeWH(50, 50);
 
     SkScalar unit = rand.nextUScalar1();
     if (unit <= 0.3) {
 //        SkDebugf("save\n");
@@ skipping 19 matching lines @@
 
 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);
 
-    SkPicture extra_save_picture;
-    extra_save_picture.beginRecording(100, 100);
-    extra_save_picture.getRecordingCanvas()->save();
-    extra_save_picture.getRecordingCanvas()->translate(10, 10);
-    extra_save_picture.getRecordingCanvas()->drawRect(rect, paint);
-    extra_save_picture.getRecordingCanvas()->save();
-    extra_save_picture.getRecordingCanvas()->translate(10, 10);
-    extra_save_picture.getRecordingCanvas()->drawRect(rect, paint);
+    SkPictureRecorder recorder;
 
-    testCanvas.drawPicture(extra_save_picture);
-    REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
+    {
+        // Create picture with 2 unbalanced saves
+        SkCanvas* canvas = recorder.beginRecording(100, 100);
+        canvas->save();
+        canvas->translate(10, 10);
+        canvas->drawRect(rect, paint);
+        canvas->save();
+        canvas->translate(10, 10);
+        canvas->drawRect(rect, paint);
+        SkAutoTUnref<SkPicture> extraSavePicture(recorder.endRecording());
+
+        testCanvas.drawPicture(*extraSavePicture);
+        REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
+    }
 
     set_canvas_to_save_count_4(&testCanvas);
 
-    SkPicture extra_restore_picture;
-    extra_restore_picture.beginRecording(100, 100);
-    extra_restore_picture.getRecordingCanvas()->save();
-    extra_restore_picture.getRecordingCanvas()->translate(10, 10);
-    extra_restore_picture.getRecordingCanvas()->drawRect(rect, paint);
-    extra_restore_picture.getRecordingCanvas()->save();
-    extra_restore_picture.getRecordingCanvas()->translate(10, 10);
-    extra_restore_picture.getRecordingCanvas()->drawRect(rect, paint);
-    extra_restore_picture.getRecordingCanvas()->restore();
-    extra_restore_picture.getRecordingCanvas()->restore();
-    extra_restore_picture.getRecordingCanvas()->restore();
-    extra_restore_picture.getRecordingCanvas()->restore();
+    {
+        // Create picture with 2 unbalanced restores
+        SkCanvas* canvas = recorder.beginRecording(100, 100);
+        canvas->save();
+        canvas->translate(10, 10);
+        canvas->drawRect(rect, paint);
+        canvas->save();
+        canvas->translate(10, 10);
+        canvas->drawRect(rect, paint);
+        canvas->restore();
+        canvas->restore();
+        canvas->restore();
+        canvas->restore();
+        SkAutoTUnref<SkPicture> extraRestorePicture(recorder.endRecording());
 
-    testCanvas.drawPicture(extra_save_picture);
-    REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
+        testCanvas.drawPicture(*extraRestorePicture);
+        REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
+    }
 
-    SkPicture no_save_picture;
-    extra_restore_picture.beginRecording(100, 100);
-    extra_restore_picture.getRecordingCanvas()->translate(10, 10);
-    extra_restore_picture.getRecordingCanvas()->drawRect(rect, paint);
+    set_canvas_to_save_count_4(&testCanvas);
 
-    testCanvas.drawPicture(extra_save_picture);
-    REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
-    REPORTER_ASSERT(reporter, testCanvas.getTotalMatrix().isIdentity());
+    {
+        SkCanvas* canvas = recorder.beginRecording(100, 100);
+        canvas->translate(10, 10);
+        canvas->drawRect(rect, paint);
+        SkAutoTUnref<SkPicture> noSavePicture(recorder.endRecording());
+
+        testCanvas.drawPicture(*noSavePicture);
+        REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
+        REPORTER_ASSERT(reporter, testCanvas.getTotalMatrix().isIdentity());
+    }
 }
 
 static void test_peephole() {
     SkRandom rand;
 
+    SkPictureRecorder recorder;
+
     for (int j = 0; j < 100; j++) {
         SkRandom rand2(rand); // remember the seed
 
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(100, 100);
+        SkCanvas* canvas = recorder.beginRecording(100, 100);
 
         for (int i = 0; i < 1000; ++i) {
             rand_op(canvas, rand);
         }
-        picture.endRecording();
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         rand = rand2;
     }
 
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(100, 100);
+        SkCanvas* canvas = recorder.beginRecording(100, 100);
         SkRect rect = SkRect::MakeWH(50, 50);
 
         for (int i = 0; i < 100; ++i) {
             canvas->save();
         }
         while (canvas->getSaveCount() > 1) {
             canvas->clipRect(rect);
             canvas->restore();
         }
-        picture.endRecording();
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     }
 }
 
 #ifndef SK_DEBUG
 // Only test this is in release mode. We deliberately crash in debug mode, since a valid caller
 // should never do this.
 static void test_bad_bitmap() {
     // This bitmap has a width and height but no pixels. As a result, attempting to record it will
     // fail.
     SkBitmap bm;
     bm.setConfig(SkImageInfo::MakeN32Premul(100, 100));
-    SkPicture picture;
-    SkCanvas* recordingCanvas = picture.beginRecording(100, 100);
+    SkPictureRecorder recorder;
+    SkCanvas* recordingCanvas = recorder.beginRecording(100, 100);
     recordingCanvas->drawBitmap(bm, 0, 0);
-    picture.endRecording();
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     SkCanvas canvas;
-    canvas.drawPicture(picture);
+    canvas.drawPicture(*picture);
 }
 #endif
 
 static SkData* encode_bitmap_to_data(size_t*, const SkBitmap& bm) {
     return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100);
 }
 
 static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
-    SkPicture picture;
-    SkCanvas* canvas = picture.beginRecording(bitmap.width(), bitmap.height());
+    SkPictureRecorder recorder;
+    SkCanvas* canvas = recorder.beginRecording(bitmap.width(), bitmap.height());
     canvas->drawBitmap(bitmap, 0, 0);
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+
     SkDynamicMemoryWStream wStream;
-    picture.serialize(&wStream, &encode_bitmap_to_data);
+    picture->serialize(&wStream, &encode_bitmap_to_data);
     return wStream.copyToData();
 }
 
 struct ErrorContext {
     int fErrors;
     skiatest::Reporter* fReporter;
 };
 
 static void assert_one_parse_error_cb(SkError error, void* context) {
     ErrorContext* errorContext = static_cast<ErrorContext*>(context);
@@ skipping 39 matching lines @@
     REPORTER_ASSERT(reporter, pictureFromStream.get() != NULL);
     SkClearLastError();
     SkSetErrorCallback(NULL, NULL);
 }
 
 static void test_clone_empty(skiatest::Reporter* reporter) {
     // This is a regression test for crbug.com/172062
     // Before the fix, we used to crash accessing a null pointer when we
     // had a picture with no paints. This test passes by not crashing.
     {
-        SkPicture picture;
-        picture.beginRecording(1, 1);
-        picture.endRecording();
-        SkPicture* destPicture = picture.clone();
+        SkPictureRecorder recorder;
+        recorder.beginRecording(1, 1);
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+        SkAutoTUnref<SkPicture> destPicture(picture->clone());
         REPORTER_ASSERT(reporter, NULL != destPicture);
-        destPicture->unref();
-    }
-    {
-        // Test without call to endRecording
-        SkPicture picture;
-        picture.beginRecording(1, 1);
-        SkPicture* destPicture = picture.clone();
-        REPORTER_ASSERT(reporter, NULL != destPicture);
-        destPicture->unref();
     }
 }
 
 static void test_draw_empty(skiatest::Reporter* reporter) {
     SkBitmap result;
     make_bm(&result, 2, 2, SK_ColorBLACK, false);
 
     SkCanvas canvas(result);
 
     {
         // stock SkPicture
-        SkPicture picture;
-        picture.beginRecording(1, 1);
-        picture.endRecording();
+        SkPictureRecorder recorder;
+        recorder.beginRecording(1, 1);
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
-        canvas.drawPicture(picture);
+        canvas.drawPicture(*picture);
     }
 
     {
         // tile grid
         SkTileGridPicture::TileGridInfo gridInfo;
         gridInfo.fMargin.setEmpty();
         gridInfo.fOffset.setZero();
         gridInfo.fTileInterval.set(1, 1);
 
-        SkTileGridPicture picture(1, 1, gridInfo);
-        picture.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
-        picture.endRecording();
+        SkAutoTUnref<SkPictureFactory> factory(SkNEW_ARGS(SkTileGridPictureFactory, (gridInfo)));
+        SkPictureRecorder recorder(factory);
+        recorder.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
-        canvas.drawPicture(picture);
+        canvas.drawPicture(*picture);
     }
 
     {
         // RTree
-        SkPicture picture;
-        picture.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
-        picture.endRecording();
+        SkPictureRecorder recorder;
+        recorder.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
-        canvas.drawPicture(picture);
+        canvas.drawPicture(*picture);
     }
 
     {
         // quad tree
-        SkQuadTreePicture picture(SkIRect::MakeWH(1, 1));
-        picture.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
-        picture.endRecording();
+        SkAutoTUnref<SkPictureFactory> factory(SkNEW(SkQuadTreePictureFactory));
+        SkPictureRecorder recorder(factory);
+        recorder.beginRecording(1, 1, SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
-        canvas.drawPicture(picture);
+        canvas.drawPicture(*picture);
     }
 }
 
 static void test_clip_bound_opt(skiatest::Reporter* reporter) {
     // Test for crbug.com/229011
     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(4), SkIntToScalar(4),
                                     SkIntToScalar(2), SkIntToScalar(2));
     SkRect rect2 = SkRect::MakeXYWH(SkIntToScalar(7), SkIntToScalar(7),
                                     SkIntToScalar(1), SkIntToScalar(1));
     SkRect rect3 = SkRect::MakeXYWH(SkIntToScalar(6), SkIntToScalar(6),
                                     SkIntToScalar(1), SkIntToScalar(1));
 
     SkPath invPath;
     invPath.addOval(rect1);
     invPath.setFillType(SkPath::kInverseEvenOdd_FillType);
     SkPath path;
     path.addOval(rect2);
     SkPath path2;
     path2.addOval(rect3);
     SkIRect clipBounds;
+    SkPictureRecorder recorder;
     // Minimalist test set for 100% code coverage of
     // SkPictureRecord::updateClipConservativelyUsingBounds
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10,
             SkPicture::kUsePathBoundsForClip_RecordingFlag);
         canvas->clipPath(invPath, SkRegion::kIntersect_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
     }
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10,
             SkPicture::kUsePathBoundsForClip_RecordingFlag);
         canvas->clipPath(path, SkRegion::kIntersect_Op);
         canvas->clipPath(invPath, SkRegion::kIntersect_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10,
             SkPicture::kUsePathBoundsForClip_RecordingFlag);
         canvas->clipPath(path, SkRegion::kIntersect_Op);
         canvas->clipPath(invPath, SkRegion::kUnion_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
     }
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10,
             SkPicture::kUsePathBoundsForClip_RecordingFlag);
         canvas->clipPath(path, SkRegion::kDifference_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 0 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 10 == clipBounds.fRight);
     }
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10,
             SkPicture::kUsePathBoundsForClip_RecordingFlag);
         canvas->clipPath(path, SkRegion::kReverseDifference_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         // True clip is actually empty in this case, but the best
         // determination we can make using only bounds as input is that the
         // clip is included in the bounds of 'path'.
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 7 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
     {
-        SkPicture picture;
-        SkCanvas* canvas = picture.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10,
             SkPicture::kUsePathBoundsForClip_RecordingFlag);
         canvas->clipPath(path, SkRegion::kIntersect_Op);
         canvas->clipPath(path2, SkRegion::kXOR_Op);
         bool nonEmpty = canvas->getClipDeviceBounds(&clipBounds);
         REPORTER_ASSERT(reporter, true == nonEmpty);
         REPORTER_ASSERT(reporter, 6 == clipBounds.fLeft);
         REPORTER_ASSERT(reporter, 6 == clipBounds.fTop);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fBottom);
         REPORTER_ASSERT(reporter, 8 == clipBounds.fRight);
     }
@@ skipping 37 matching lines @@
 
     unsigned getClipCount() const { return fClipCount; }
 
 private:
     unsigned fClipCount;
 
     typedef SkCanvas INHERITED;
 };
 
 static void test_clip_expansion(skiatest::Reporter* reporter) {
-    SkPicture picture;
-    SkCanvas* canvas = picture.beginRecording(10, 10, 0);
+    SkPictureRecorder recorder;
+    SkCanvas* canvas = recorder.beginRecording(10, 10, 0);
 
     canvas->clipRect(SkRect::MakeEmpty(), SkRegion::kReplace_Op);
     // The following expanding clip should not be skipped.
     canvas->clipRect(SkRect::MakeXYWH(4, 4, 3, 3), SkRegion::kUnion_Op);
     // Draw something so the optimizer doesn't just fold the world.
     SkPaint p;
     p.setColor(SK_ColorBLUE);
     canvas->drawPaint(p);
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     ClipCountingCanvas testCanvas(10, 10);
-    picture.draw(&testCanvas);
+    picture->draw(&testCanvas);
 
     // Both clips should be present on playback.
     REPORTER_ASSERT(reporter, testCanvas.getClipCount() == 2);
 }
 
 static void test_hierarchical(skiatest::Reporter* reporter) {
     SkBitmap bm;
     make_bm(&bm, 10, 10, SK_ColorRED, true);
 
-    SkCanvas* canvas;
+    SkPictureRecorder recorder;
 
-    SkPicture childPlain;
-    childPlain.beginRecording(10, 10);
-    childPlain.endRecording();
-    REPORTER_ASSERT(reporter, !childPlain.willPlayBackBitmaps()); // 0
+    recorder.beginRecording(10, 10);
+    SkAutoTUnref<SkPicture> childPlain(recorder.endRecording());
+    REPORTER_ASSERT(reporter, !childPlain->willPlayBackBitmaps()); // 0
 
-    SkPicture childWithBitmap;
-    childWithBitmap.beginRecording(10, 10)->drawBitmap(bm, 0, 0);
-    childWithBitmap.endRecording();
-    REPORTER_ASSERT(reporter, childWithBitmap.willPlayBackBitmaps()); // 1
+    recorder.beginRecording(10, 10)->drawBitmap(bm, 0, 0);
+    SkAutoTUnref<SkPicture> childWithBitmap(recorder.endRecording());
+    REPORTER_ASSERT(reporter, childWithBitmap->willPlayBackBitmaps()); // 1
 
-    SkPicture parentPP;
-    canvas = parentPP.beginRecording(10, 10);
-    canvas->drawPicture(childPlain);
-    parentPP.endRecording();
-    REPORTER_ASSERT(reporter, !parentPP.willPlayBackBitmaps()); // 0
-
-    SkPicture parentPWB;
-    canvas = parentPWB.beginRecording(10, 10);
-    canvas->drawPicture(childWithBitmap);
-    parentPWB.endRecording();
-    REPORTER_ASSERT(reporter, parentPWB.willPlayBackBitmaps()); // 1
-
-    SkPicture parentWBP;
-    canvas = parentWBP.beginRecording(10, 10);
-    canvas->drawBitmap(bm, 0, 0);
-    canvas->drawPicture(childPlain);
-    parentWBP.endRecording();
-    REPORTER_ASSERT(reporter, parentWBP.willPlayBackBitmaps()); // 1
-
-    SkPicture parentWBWB;
-    canvas = parentWBWB.beginRecording(10, 10);
-    canvas->drawBitmap(bm, 0, 0);
-    canvas->drawPicture(childWithBitmap);
-    parentWBWB.endRecording();
-    REPORTER_ASSERT(reporter, parentWBWB.willPlayBackBitmaps()); // 2
+    {
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        canvas->drawPicture(*childPlain);
+        SkAutoTUnref<SkPicture> parentPP(recorder.endRecording());
+        REPORTER_ASSERT(reporter, !parentPP->willPlayBackBitmaps()); // 0
+    }
+    {
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        canvas->drawPicture(*childWithBitmap);
+        SkAutoTUnref<SkPicture> parentPWB(recorder.endRecording());
+        REPORTER_ASSERT(reporter, parentPWB->willPlayBackBitmaps()); // 1
+    }
+    {
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        canvas->drawBitmap(bm, 0, 0);
+        canvas->drawPicture(*childPlain);
+        SkAutoTUnref<SkPicture> parentWBP(recorder.endRecording());
+        REPORTER_ASSERT(reporter, parentWBP->willPlayBackBitmaps()); // 1
+    }
+    {
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        canvas->drawBitmap(bm, 0, 0);
+        canvas->drawPicture(*childWithBitmap);
+        SkAutoTUnref<SkPicture> parentWBWB(recorder.endRecording());
+        REPORTER_ASSERT(reporter, parentWBWB->willPlayBackBitmaps()); // 2
+    }
 }
 
 DEF_TEST(Picture, reporter) {
 #ifdef SK_DEBUG
     test_deleting_empty_playback();
     test_serializing_empty_picture();
 #else
     test_bad_bitmap();
 #endif
     test_unbalanced_save_restores(reporter);
@@ skipping 22 matching lines @@
 }
 
 static void test_draw_bitmaps(SkCanvas* canvas) {
     SkBitmap empty;
     draw_bitmaps(empty, canvas);
     empty.setConfig(SkImageInfo::MakeN32Premul(10, 10));
     draw_bitmaps(empty, canvas);
 }
 
 DEF_TEST(Picture_EmptyBitmap, r) {
-    SkPicture picture;
-    test_draw_bitmaps(picture.beginRecording(10, 10));
-    picture.endRecording();
+    SkPictureRecorder recorder;
+    test_draw_bitmaps(recorder.beginRecording(10, 10));
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 }
 
 DEF_TEST(Canvas_EmptyBitmap, r) {
     SkBitmap dst;
     dst.allocN32Pixels(10, 10);
     SkCanvas canvas(dst);
 
     test_draw_bitmaps(&canvas);
 }