Staged removal of SkPicture-derived classes

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 285 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);
+    SkCanvas* canvas = recorder.beginRecording(1000, 1000, NULL, 0);
     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);
+    recorder.beginRecording(0, 0, NULL, 0);
     // Turns that into an SkPicturePlayback
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     // Deletes the old SkPicturePlayback, and creates a new SkPictureRecord
-    recorder.beginRecording(0, 0);
+    recorder.beginRecording(0, 0, NULL, 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);
+    recorder.beginRecording(0, 0, NULL, 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 26 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);
+        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
         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);
+        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
         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);
+        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
         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);
+        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
 
         for (int i = 0; i < 1000; ++i) {
             rand_op(canvas, rand);
         }
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         rand = rand2;
     }
 
     {
-        SkCanvas* canvas = recorder.beginRecording(100, 100);
+        SkCanvas* canvas = recorder.beginRecording(100, 100, NULL, 0);
         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.setConfig(SkImageInfo::MakeN32Premul(100, 100));
     SkPictureRecorder recorder;
-    SkCanvas* recordingCanvas = recorder.beginRecording(100, 100);
+    SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, NULL, 0);
     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());
+    SkCanvas* canvas = recorder.beginRecording(bitmap.width(), bitmap.height(), NULL, 0);
     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);
+        recorder.beginRecording(1, 1, NULL, 0);
         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);
+        recorder.beginRecording(1, 1, NULL, 0);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         canvas.drawPicture(*picture);
     }
 
     {
         // tile grid
-        SkTileGridPicture::TileGridInfo gridInfo;
+        SkTileGridFactory::TileGridInfo gridInfo;
         gridInfo.fMargin.setEmpty();
         gridInfo.fOffset.setZero();
         gridInfo.fTileInterval.set(1, 1);
 
-        SkAutoTUnref<SkPictureFactory> factory(SkNEW_ARGS(SkTileGridPictureFactory, (gridInfo)));
-        SkPictureRecorder recorder(factory);
-        recorder.beginRecording(1, 1);
+        SkTileGridFactory factory(gridInfo);
+        SkPictureRecorder recorder;
+        recorder.beginRecording(1, 1, &factory, 0);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         canvas.drawPicture(*picture);
     }
 
     {
         // RTree
-        SkAutoTUnref<SkPictureFactory> factory(SkNEW(SkRTreePictureFactory));
-        SkPictureRecorder recorder(factory);
-        recorder.beginRecording(1, 1);
+        SkRTreeFactory factory;
+        SkPictureRecorder recorder;
+        recorder.beginRecording(1, 1, &factory, 0);
         SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
         canvas.drawPicture(*picture);
     }
 
     {
         // quad tree
-        SkAutoTUnref<SkPictureFactory> factory(SkNEW(SkQuadTreePictureFactory));
-        SkPictureRecorder recorder(factory);
-        recorder.beginRecording(1, 1);
+        SkQuadTreeFactory factory;
+        SkPictureRecorder recorder;
+        recorder.beginRecording(1, 1, &factory, 0);
         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,
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
             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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
             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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
             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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
             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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
             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);
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10,
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL,
             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 38 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, 0);
+    SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 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);
 
     // 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);
+    recorder.beginRecording(10, 10, NULL, 0);
     SkAutoTUnref<SkPicture> childPlain(recorder.endRecording());
     REPORTER_ASSERT(reporter, !childPlain->willPlayBackBitmaps()); // 0
 
-    recorder.beginRecording(10, 10)->drawBitmap(bm, 0, 0);
+    recorder.beginRecording(10, 10, NULL, 0)->drawBitmap(bm, 0, 0);
     SkAutoTUnref<SkPicture> childWithBitmap(recorder.endRecording());
     REPORTER_ASSERT(reporter, childWithBitmap->willPlayBackBitmaps()); // 1
 
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
         canvas->drawPicture(*childPlain);
         SkAutoTUnref<SkPicture> parentPP(recorder.endRecording());
         REPORTER_ASSERT(reporter, !parentPP->willPlayBackBitmaps()); // 0
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
         canvas->drawPicture(*childWithBitmap);
         SkAutoTUnref<SkPicture> parentPWB(recorder.endRecording());
         REPORTER_ASSERT(reporter, parentPWB->willPlayBackBitmaps()); // 1
     }
     {
-        SkCanvas* canvas = recorder.beginRecording(10, 10);
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
         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);
+        SkCanvas* canvas = recorder.beginRecording(10, 10, NULL, 0);
         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);
+    SkCanvas* canvas = recorder.beginRecording(1, 1, NULL, 0);
     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 57 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) {
     SkPictureRecorder recorder;
-    test_draw_bitmaps(recorder.beginRecording(10, 10));
+    test_draw_bitmaps(recorder.beginRecording(10, 10, NULL, 0));
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 }
 
 DEF_TEST(Canvas_EmptyBitmap, r) {
     SkBitmap dst;
     dst.allocN32Pixels(10, 10);
     SkCanvas canvas(dst);
 
     test_draw_bitmaps(&canvas);
 }