Remove SkPicture::kUsePathBoundsForClip_RecordingFlag

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 297 matching lines @@
     *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) {
     SkPictureRecorder recorder;
-    SkCanvas* canvas = recorder.beginRecording(1000, 1000, NULL, 0);
+    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();
     }
@@ skipping 335 matching lines @@
         }
     }
 }
 
 #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() {
     SkPictureRecorder recorder;
     // Creates an SkPictureRecord
-    recorder.beginRecording(0, 0, NULL, 0);
+    recorder.beginRecording(0, 0);
     // Turns that into an SkPicturePlayback
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     // Deletes the old SkPicturePlayback, and creates a new SkPictureRecord
-    recorder.beginRecording(0, 0, NULL, 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() {
     SkPictureRecorder recorder;
-    recorder.beginRecording(0, 0, NULL, 0);
+    recorder.beginRecording(0, 0);
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     SkDynamicMemoryWStream stream;
     picture->serialize(&stream);
 }
 #endif
 
 static void rand_op(SkCanvas* canvas, SkRandom& rand) {
     SkPaint paint;
     SkRect rect = SkRect::MakeWH(50, 50);
 
@@ skipping 11 matching lines @@
 //        SkDebugf("draw\n");
         canvas->drawPaint(paint);
     }
 }
 
 #if SK_SUPPORT_GPU
 static void test_gpu_veto(skiatest::Reporter* reporter) {
 
     SkPictureRecorder recorder;
 
-    SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
+    SkCanvas* canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         SkScalar intervals[] = { 1.0f, 1.0f };
         SkAutoTUnref<SkDashPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0));
 
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setPathEffect(dash);
 
         canvas->drawPath(path, paint);
     }
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     // path effects currently render an SkPicture undesireable for GPU rendering
 
     const char *reason = NULL;
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL, &reason));
     REPORTER_ASSERT(reporter, NULL != reason);
 
-    canvas = recorder.beginRecording(100, 100, NULL, 0);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // A lot of AA concave paths currently render an SkPicture undesireable for GPU rendering
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
 
-    canvas = recorder.beginRecording(100, 100, NULL, 0);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
@@ skipping 33 matching lines @@
     //      Restore
     // 3)
     //      SaveLayer w/ copyable paint
     //      Restore
     // 4)
     //      SaveLayer w/ non-copyable paint
     //      Restore
     {
         SkPictureRecorder recorder;
 
-        SkCanvas* c = recorder.beginRecording(kWidth, kHeight, NULL, 0);
+        SkCanvas* c = recorder.beginRecording(kWidth, kHeight);
         // 1)
         c->saveLayer(NULL, NULL);
         c->restore();
 
         // 2)
         c->saveLayer(NULL, NULL);
             c->translate(kWidth/2, kHeight/2);
             SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2);
             c->saveLayer(&r, NULL);
             c->restore();
@@ skipping 146 matching lines @@
     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);
+        SkCanvas* canvas = recorder2.beginRecording(10, 10);
 
         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);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
 
         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);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
 
         SkRect r = SkRect::MakeWH(5, 5);
         SkPaint p;
 
         canvas->drawRect(r, p);
 
         SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
 
         REPORTER_ASSERT(reporter, !copy->willPlayBackBitmaps());
 
@@ skipping 19 matching lines @@
 
     REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
 
     SkPaint paint;
     SkRect rect = SkRect::MakeLTRB(-10000000, -10000000, 10000000, 10000000);
 
     SkPictureRecorder recorder;
 
     {
         // Create picture with 2 unbalanced saves
-        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
+        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);
 
     {
         // Create picture with 2 unbalanced restores
-        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
+        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(extraRestorePicture);
         REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
     }
 
     set_canvas_to_save_count_4(&testCanvas);
 
     {
-        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
+        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
 
-        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
+        SkCanvas* canvas = recorder.beginRecording(100, 100);
 
         for (int i = 0; i < 1000; ++i) {
             rand_op(canvas, rand);
         }
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         rand = rand2;
     }
 
     {
-        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
+        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();
         }
         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.setInfo(SkImageInfo::MakeN32Premul(100, 100));
     SkPictureRecorder recorder;
-    SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, NULL, 0);
+    SkCanvas* recordingCanvas = recorder.beginRecording(100, 100);
     recordingCanvas->drawBitmap(bm, 0, 0);
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     SkCanvas canvas;
     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) {
     SkPictureRecorder recorder;
-    SkCanvas* canvas = recorder.beginRecording(bitmap.width(), bitmap.height(), NULL, 0);
+    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);
     return wStream.copyToData();
 }
 
 struct ErrorContext {
     int fErrors;
@@ skipping 45 matching lines @@
     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.
     {
         SkPictureRecorder recorder;
-        recorder.beginRecording(1, 1, NULL, 0);
+        recorder.beginRecording(1, 1);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
         SkAutoTUnref<SkPicture> destPicture(picture->clone());
         REPORTER_ASSERT(reporter, NULL != destPicture);
     }
 }
 
 static void test_draw_empty(skiatest::Reporter* reporter) {
     SkBitmap result;
     make_bm(&result, 2, 2, SK_ColorBLACK, false);
 
     SkCanvas canvas(result);
 
     {
         // stock SkPicture
         SkPictureRecorder recorder;
-        recorder.beginRecording(1, 1, NULL, 0);
+        recorder.beginRecording(1, 1);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         canvas.drawPicture(picture);
     }
 
     {
         // tile grid
         SkTileGridFactory::TileGridInfo gridInfo;
         gridInfo.fMargin.setEmpty();
         gridInfo.fOffset.setZero();
         gridInfo.fTileInterval.set(1, 1);
 
         SkTileGridFactory factory(gridInfo);
         SkPictureRecorder recorder;
-        recorder.beginRecording(1, 1, &factory, 0);
+        recorder.beginRecording(1, 1, &factory);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         canvas.drawPicture(picture);
     }
 
     {
         // RTree
         SkRTreeFactory factory;
         SkPictureRecorder recorder;
-        recorder.beginRecording(1, 1, &factory, 0);
+        recorder.beginRecording(1, 1, &factory);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         canvas.drawPicture(picture);
     }
 
     {
         // quad tree
         SkQuadTreeFactory factory;
         SkPictureRecorder recorder;
-        recorder.beginRecording(1, 1, &factory, 0);
+        recorder.beginRecording(1, 1, &factory);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         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
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
-            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
         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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
-            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
         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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
-            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
         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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
-            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
         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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
-            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
         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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
-            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+        SkCanvas* canvas = recorder.beginRecording(10, 10);
         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) {
     SkPictureRecorder recorder;
-    SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
+    SkCanvas* canvas = recorder.beginRecording(10, 10);
 
     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);
 
     // 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);
 
     SkPictureRecorder recorder;
 
-    recorder.beginRecording(10, 10, NULL, 0);
+    recorder.beginRecording(10, 10);
     SkAutoTUnref<SkPicture> childPlain(recorder.endRecording());
     REPORTER_ASSERT(reporter, !childPlain->willPlayBackBitmaps()); // 0
 
-    recorder.beginRecording(10, 10, NULL, 0)->drawBitmap(bm, 0, 0);
+    recorder.beginRecording(10, 10)->drawBitmap(bm, 0, 0);
     SkAutoTUnref<SkPicture> childWithBitmap(recorder.endRecording());
     REPORTER_ASSERT(reporter, childWithBitmap->willPlayBackBitmaps()); // 1
 
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
+        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, NULL, 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, NULL, 0);
+        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, NULL, 0);
+        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
     }
 }
 
 static void test_gen_id(skiatest::Reporter* reporter) {
 
     SkPicture empty;
 
     // Empty pictures should still have a valid ID
     REPORTER_ASSERT(reporter, empty.uniqueID() != SK_InvalidGenID);
 
     SkPictureRecorder recorder;
 
-    SkCanvas* canvas = recorder.beginRecording(1, 1, NULL, 0);
+    SkCanvas* canvas = recorder.beginRecording(1, 1);
     canvas->drawARGB(255, 255, 255, 255);
     SkAutoTUnref<SkPicture> hasData(recorder.endRecording());
     // picture should have a non-zero id after recording
     REPORTER_ASSERT(reporter, hasData->uniqueID() != SK_InvalidGenID);
 
     // both pictures should have different ids
     REPORTER_ASSERT(reporter, hasData->uniqueID() != empty.uniqueID());
 
     // test out copy constructor
     SkPicture copyWithData(*hasData);
@@ skipping 66 matching lines @@
 
 static void test_draw_bitmaps(SkCanvas* canvas) {
     SkBitmap empty;
     draw_bitmaps(empty, canvas);
     empty.setInfo(SkImageInfo::MakeN32Premul(10, 10));
     draw_bitmaps(empty, canvas);
 }
 
 DEF_TEST(Picture_EmptyBitmap, r) {
     SkPictureRecorder recorder;
-    test_draw_bitmaps(recorder.beginRecording(10, 10, NULL, 0));
+    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);
 }