return pictures as sk_sp

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 "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 36 matching lines @@
 
 // For a while willPlayBackBitmaps() ignored SkImages and just looked for SkBitmaps.
 static void test_images_are_found_by_willPlayBackBitmaps(skiatest::Reporter* reporter) {
     // We just need _some_ SkImage
     const SkPMColor pixel = 0;
     const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
     sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(info, &pixel, sizeof(pixel))));
 
     SkPictureRecorder recorder;
     recorder.beginRecording(100,100)->drawImage(image, 0,0);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     REPORTER_ASSERT(reporter, picture->willPlayBackBitmaps());
 }
 
 /* Hit a few SkPicture::Analysis cases not handled elsewhere. */
 static void test_analysis(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
     SkCanvas* canvas = recorder.beginRecording(100, 100);
     {
         canvas->drawRect(SkRect::MakeWH(10, 10), SkPaint ());
     }
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     REPORTER_ASSERT(reporter, !picture->willPlayBackBitmaps());
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         // CreateBitmapShader is too smart for us; an empty (or 1x1) bitmap shader
         // gets optimized into a non-bitmap form, so we create a 2x2 bitmap here.
         SkBitmap bitmap;
         bitmap.allocPixels(SkImageInfo::MakeN32Premul(2, 2));
         bitmap.eraseColor(SK_ColorBLUE);
         *(bitmap.getAddr32(0, 0)) = SK_ColorGREEN;
         paint.setShader(SkShader::MakeBitmapShader(bitmap, SkShader::kClamp_TileMode,
                                                    SkShader::kClamp_TileMode));
         REPORTER_ASSERT(reporter, paint.getShader()->isABitmap());
 
         canvas->drawRect(SkRect::MakeWH(10, 10), paint);
     }
-    picture.reset(recorder.endRecording());
-    REPORTER_ASSERT(reporter, picture->willPlayBackBitmaps());
+    REPORTER_ASSERT(reporter, recorder.finishRecordingAsPicture()->willPlayBackBitmaps());
 }
 
 
 #ifdef SK_DEBUG
 // Ensure that deleting an empty SkPicture does not assert. Asserts only fire
 // in debug mode, so only run in debug mode.
 static void test_deleting_empty_picture() {
     SkPictureRecorder recorder;
     // Creates an SkPictureRecord
     recorder.beginRecording(0, 0);
     // Turns that into an SkPicture
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     // Ceates a new SkPictureRecord
     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);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     SkDynamicMemoryWStream 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();
@@ skipping 27 matching lines @@
         SkAutoTUnref<SkPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0));
 
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setPathEffect(dash);
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     // path effects currently render an SkPicture undesireable for GPU rendering
 
     const char *reason = nullptr;
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr, &reason));
     REPORTER_ASSERT(reporter, reason);
 
     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());
+    picture = recorder.finishRecordingAsPicture();
     // A lot of small AA concave paths should be fine for GPU rendering
     REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 100);
         path.lineTo(50, 50);
         path.lineTo(100, 100);
         path.lineTo(100, 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());
+    picture = recorder.finishRecordingAsPicture();
     // A lot of large AA concave paths currently render an SkPicture undesireable for GPU rendering
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
 
     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);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(0);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     // hairline stroked AA concave paths are fine for GPU rendering
     REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25);
         paint.setPathEffect(pe)->unref();
 
         SkPoint points [2] = { { 0, 0 }, { 100, 0 } };
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, points, paint);
         }
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     // fast-path dashed effects are fine for GPU rendering ...
     REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(nullptr));
 
     canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25);
         paint.setPathEffect(pe)->unref();
 
         for (int i = 0; i < 50; ++i) {
             canvas->drawRect(SkRect::MakeWH(10, 10), paint);
         }
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     // ... but only when applied to drawPoint() calls
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
 
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100, 100);
     {
         canvas->drawPicture(picture.get());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(nullptr));
 }
 
 #endif
 
 static void test_savelayer_extraction(skiatest::Reporter* reporter) {
     static const int kWidth = 100;
     static const int kHeight = 100;
 
     // Create complex paint that the bounding box computation code can't
     // optimize away
     SkScalar blueToRedMatrix[20] = { 0 };
     blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
     SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
     SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get()));
 
     SkPaint complexPaint;
     complexPaint.setImageFilter(filter);
 
-    SkAutoTUnref<SkPicture> pict, child;
+    sk_sp<SkPicture> pict, child;
     SkRTreeFactory bbhFactory;
 
     {
         SkPictureRecorder recorder;
 
         SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight),
                                               &bbhFactory,
                                               SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
 
         c->saveLayer(nullptr, &complexPaint);
         c->restore();
 
-        child.reset(recorder.endRecording());
+        child = recorder.finishRecordingAsPicture();
     }
 
     // create a picture with the structure:
     // 1)
     //      SaveLayer
     //      Restore
     // 2)
     //      SaveLayer
     //          Translate
     //          SaveLayer w/ bound
@@ skipping 47 matching lines @@
         {
             SkPaint picturePaint;
             SkMatrix trans;
             trans.setTranslate(10, 10);
 
             c->saveLayer(nullptr, &layerPaint);  // layer #6
                 c->drawPicture(child, &trans, &picturePaint); // layer #7 inside picture
             c->restore();
         }
 
-        pict.reset(recorder.endRecording());
+        pict = recorder.finishRecordingAsPicture();
     }
 
     // Now test out the SaveLayer extraction
     if (!SkCanvas::Internal_Private_GetIgnoreSaveLayerBounds()) {
         const SkBigPicture* bp = pict->asSkBigPicture();
         REPORTER_ASSERT(reporter, bp);
 
         const SkBigPicture::AccelData* data = bp->accelData();
         REPORTER_ASSERT(reporter, data);
 
@@ skipping 57 matching lines @@
         REPORTER_ASSERT(reporter, nullptr == info4.fPicture);
         REPORTER_ASSERT(reporter, kWidth == info4.fBounds.width() &&
                                   kHeight == info4.fBounds.height());
         REPORTER_ASSERT(reporter, 0 == info4.fBounds.fLeft && 0 == info4.fBounds.fTop);
         REPORTER_ASSERT(reporter, info4.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info4.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, info4.fPaint);
         REPORTER_ASSERT(reporter, !info4.fIsNested &&
                                   info4.fHasNestedLayers); // has a nested SL
 
-        REPORTER_ASSERT(reporter, child == info5.fPicture); // in a child picture
+        REPORTER_ASSERT(reporter, child.get() == info5.fPicture); // in a child picture
         REPORTER_ASSERT(reporter, kWidth == info5.fBounds.width() &&
                                   kHeight == info5.fBounds.height());
         REPORTER_ASSERT(reporter, 0 == info5.fBounds.fLeft && 0 == info5.fBounds.fTop);
         REPORTER_ASSERT(reporter, info5.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info5.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, nullptr != info5.fPaint);
         REPORTER_ASSERT(reporter, info5.fIsNested && !info5.fHasNestedLayers); // is nested
 
         REPORTER_ASSERT(reporter, nullptr == info6.fPicture);
         REPORTER_ASSERT(reporter, kWidth-10 == info6.fBounds.width() &&
                                   kHeight-10 == info6.fBounds.height());
         REPORTER_ASSERT(reporter, 10 == info6.fBounds.fLeft && 10 == info6.fBounds.fTop);
         REPORTER_ASSERT(reporter, info6.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info6.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, info6.fPaint);
         REPORTER_ASSERT(reporter, !info6.fIsNested &&
                                   info6.fHasNestedLayers); // has a nested SL
 
-        REPORTER_ASSERT(reporter, child == info7.fPicture); // in a child picture
+        REPORTER_ASSERT(reporter, child.get() == info7.fPicture); // in a child picture
         REPORTER_ASSERT(reporter, kWidth == info7.fBounds.width() &&
                                   kHeight == info7.fBounds.height());
         REPORTER_ASSERT(reporter, 0 == info7.fBounds.fLeft && 0 == info7.fBounds.fTop);
         REPORTER_ASSERT(reporter, info7.fLocalMat.isIdentity());
         REPORTER_ASSERT(reporter, info7.fPreMat.isIdentity());
         REPORTER_ASSERT(reporter, nullptr != info7.fPaint);
         REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested
     }
 }
 
 static void test_has_text(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
     SkCanvas* canvas = recorder.beginRecording(100,100);
     {
         canvas->drawRect(SkRect::MakeWH(20, 20), SkPaint());
     }
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     REPORTER_ASSERT(reporter, !picture->hasText());
 
     SkPoint point = SkPoint::Make(10, 10);
     canvas = recorder.beginRecording(100,100);
     {
         canvas->drawText("Q", 1, point.fX, point.fY, SkPaint());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, picture->hasText());
 
     canvas = recorder.beginRecording(100,100);
     {
         canvas->drawPosText("Q", 1, &point, SkPaint());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, picture->hasText());
 
     canvas = recorder.beginRecording(100,100);
     {
         canvas->drawPosTextH("Q", 1, &point.fX, point.fY, SkPaint());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, picture->hasText());
 
     canvas = recorder.beginRecording(100,100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         canvas->drawTextOnPathHV("Q", 1, path, point.fX, point.fY, SkPaint());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, picture->hasText());
 
     canvas = recorder.beginRecording(100,100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         canvas->drawTextOnPath("Q", 1, path, nullptr, SkPaint());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, picture->hasText());
 
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100,100);
     {
         canvas->drawPicture(picture.get());
     }
-    picture.reset(recorder.endRecording());
+    picture = recorder.finishRecordingAsPicture();
     REPORTER_ASSERT(reporter, picture->hasText());
 }
 
 static void set_canvas_to_save_count_4(SkCanvas* canvas) {
     canvas->restoreToCount(1);
     canvas->save();
     canvas->save();
     canvas->save();
 }
 
@@ skipping 48 matching lines @@
     // so expect to have seen no more than num{Saves,SaveLayers,Restores}.
     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) {
+    static sk_sp<SkPicture> Copy(SkPictureRecorder* recorder) {
         SkPictureRecorder recorder2;
 
         SkCanvas* canvas = recorder2.beginRecording(10, 10);
 
         recorder->partialReplay(canvas);
 
-        return recorder2.endRecording();
+        return recorder2.finishRecordingAsPicture();
     }
 };
 
 static void create_imbalance(SkCanvas* canvas) {
     SkRect clipRect = SkRect::MakeWH(2, 2);
     SkRect drawRect = SkRect::MakeWH(10, 10);
     canvas->save();
         canvas->clipRect(clipRect, SkRegion::kReplace_Op);
         canvas->translate(1.0f, 1.0f);
         SkPaint p;
@@ skipping 32 matching lines @@
 // Test out SkPictureRecorder::partialReplay
 DEF_TEST(PictureRecorder_replay, reporter) {
     // check save/saveLayer state
     {
         SkPictureRecorder recorder;
 
         SkCanvas* canvas = recorder.beginRecording(10, 10);
 
         canvas->saveLayer(nullptr, nullptr);
 
-        SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
+        sk_sp<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
 
         // The extra save and restore comes from the Copy process.
-        check_save_state(reporter, copy, 2, 1, 3);
+        check_save_state(reporter, copy.get(), 2, 1, 3);
 
         canvas->saveLayer(nullptr, nullptr);
 
-        SkAutoTUnref<SkPicture> final(recorder.endRecording());
+        sk_sp<SkPicture> final(recorder.finishRecordingAsPicture());
 
-        check_save_state(reporter, final, 1, 2, 3);
+        check_save_state(reporter, final.get(), 1, 2, 3);
 
         // The copy shouldn't pick up any operations added after it was made
-        check_save_state(reporter, copy, 2, 1, 3);
+        check_save_state(reporter, copy.get(), 2, 1, 3);
     }
 
     // (partially) check leakage of draw ops
     {
         SkPictureRecorder recorder;
 
         SkCanvas* canvas = recorder.beginRecording(10, 10);
 
         SkRect r = SkRect::MakeWH(5, 5);
         SkPaint p;
 
         canvas->drawRect(r, p);
 
-        SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
+        sk_sp<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->drawBitmapRect(bm, r, nullptr);
 
-        SkAutoTUnref<SkPicture> final(recorder.endRecording());
+        sk_sp<SkPicture> final(recorder.finishRecordingAsPicture());
         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());
     }
 
     // Recreate the Android partialReplay test case
     {
         SkPictureRecorder recorder;
 
         SkCanvas* canvas = recorder.beginRecording(4, 3, nullptr, 0);
         create_imbalance(canvas);
 
         int expectedSaveCount = canvas->getSaveCount();
 
-        SkAutoTUnref<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
-        check_balance(reporter, copy);
+        sk_sp<SkPicture> copy(SkPictureRecorderReplayTester::Copy(&recorder));
+        check_balance(reporter, copy.get());
 
         REPORTER_ASSERT(reporter, expectedSaveCount = canvas->getSaveCount());
 
         // End the recording of source to test the picture finalization
         // process isn't complicated by the partialReplay step
-        SkAutoTUnref<SkPicture> final(recorder.endRecording());
+        sk_sp<SkPicture> final(recorder.finishRecordingAsPicture());
     }
 }
 
 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;
 
     {
         // 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());
+        sk_sp<SkPicture> extraSavePicture(recorder.finishRecordingAsPicture());
 
         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);
         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());
+        sk_sp<SkPicture> extraRestorePicture(recorder.finishRecordingAsPicture());
 
         testCanvas.drawPicture(extraRestorePicture);
         REPORTER_ASSERT(reporter, 4 == testCanvas.getSaveCount());
     }
 
     set_canvas_to_save_count_4(&testCanvas);
 
     {
         SkCanvas* canvas = recorder.beginRecording(100, 100);
         canvas->translate(10, 10);
         canvas->drawRect(rect, paint);
-        SkAutoTUnref<SkPicture> noSavePicture(recorder.endRecording());
+        sk_sp<SkPicture> noSavePicture(recorder.finishRecordingAsPicture());
 
         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);
 
         for (int i = 0; i < 1000; ++i) {
             rand_op(canvas, rand);
         }
-        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+        sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
         rand = rand2;
     }
 
     {
         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());
+        sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     }
 }
 
 #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);
     recordingCanvas->drawBitmap(bm, 0, 0);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     SkCanvas canvas;
     canvas.drawPicture(picture);
 }
 #endif
 
 static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(bitmap.width()),
                                                SkIntToScalar(bitmap.height()));
     canvas->drawBitmap(bitmap, 0, 0);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     SkDynamicMemoryWStream wStream;
     SkAutoTUnref<SkPixelSerializer> serializer(
             SkImageEncoder::CreatePixelSerializer());
     picture->serialize(&wStream, serializer);
     return wStream.copyToData();
 }
 
 struct ErrorContext {
     int fErrors;
@@ skipping 44 matching lines @@
     REPORTER_ASSERT(reporter, picture1->equals(picture2));
 
     // Now test that a parse error was generated when trying to create a new SkPicture without
     // providing a function to decode the bitmap.
     ErrorContext context;
     context.fErrors = 0;
     context.fReporter = reporter;
     SkSetErrorCallback(assert_one_parse_error_cb, &context);
     SkMemoryStream pictureStream(picture1);
     SkClearLastError();
-    SkAutoTUnref<SkPicture> pictureFromStream(SkPicture::CreateFromStream(&pictureStream, nullptr));
+    sk_sp<SkPicture> pictureFromStream(SkPicture::MakeFromStream(&pictureStream, nullptr));
     REPORTER_ASSERT(reporter, pictureFromStream.get() != nullptr);
     SkClearLastError();
     SkSetErrorCallback(nullptr, nullptr);
 
     // Test that using the version of CreateFromStream that just takes a stream also decodes the
     // bitmap. Drawing this picture should look exactly like the original bitmap.
     SkMD5::Digest referenceDigest;
     md5(original, &referenceDigest);
 
     SkBitmap dst;
     dst.allocPixels(original.info());
     dst.eraseColor(SK_ColorRED);
     SkCanvas canvas(dst);
 
     pictureStream.rewind();
-    pictureFromStream.reset(SkPicture::CreateFromStream(&pictureStream));
+    pictureFromStream = SkPicture::MakeFromStream(&pictureStream);
     canvas.drawPicture(pictureFromStream.get());
 
     SkMD5::Digest digest2;
     md5(dst, &digest2);
     REPORTER_ASSERT(reporter, referenceDigest == digest2);
 }
 
 static void test_clip_bound_opt(skiatest::Reporter* reporter) {
     // Test for crbug.com/229011
     SkRect rect1 = SkRect::MakeXYWH(SkIntToScalar(4), SkIntToScalar(4),
@@ skipping 84 matching lines @@
 
 static void test_cull_rect_reset(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
     SkRect bounds = SkRect::MakeWH(10, 10);
     SkRTreeFactory factory;
     SkCanvas* canvas = recorder.beginRecording(bounds, &factory);
     bounds = SkRect::MakeWH(100, 100);
     SkPaint paint;
     canvas->drawRect(bounds, paint);
     canvas->drawRect(bounds, paint);
-    SkAutoTUnref<const SkPicture> p(recorder.endRecordingAsPicture(bounds));
+    sk_sp<SkPicture> p(recorder.finishRecordingAsPictureWithCull(bounds));
     const SkBigPicture* picture = p->asSkBigPicture();
     REPORTER_ASSERT(reporter, picture);
 
     SkRect finalCullRect = picture->cullRect();
     REPORTER_ASSERT(reporter, 0 == finalCullRect.fLeft);
     REPORTER_ASSERT(reporter, 0 == finalCullRect.fTop);
     REPORTER_ASSERT(reporter, 100 == finalCullRect.fBottom);
     REPORTER_ASSERT(reporter, 100 == finalCullRect.fRight);
 
     const SkBBoxHierarchy* pictureBBH = picture->bbh();
@@ skipping 53 matching lines @@
     SkPictureRecorder recorder;
     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());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     ClipCountingCanvas testCanvas(10, 10);
     picture->playback(&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);
-    SkAutoTUnref<SkPicture> childPlain(recorder.endRecording());
+    sk_sp<SkPicture> childPlain(recorder.finishRecordingAsPicture());
     REPORTER_ASSERT(reporter, !childPlain->willPlayBackBitmaps()); // 0
 
     recorder.beginRecording(10, 10)->drawBitmap(bm, 0, 0);
-    SkAutoTUnref<SkPicture> childWithBitmap(recorder.endRecording());
+    sk_sp<SkPicture> childWithBitmap(recorder.finishRecordingAsPicture());
     REPORTER_ASSERT(reporter, childWithBitmap->willPlayBackBitmaps()); // 1
 
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
         canvas->drawPicture(childPlain);
-        SkAutoTUnref<SkPicture> parentPP(recorder.endRecording());
+        sk_sp<SkPicture> parentPP(recorder.finishRecordingAsPicture());
         REPORTER_ASSERT(reporter, !parentPP->willPlayBackBitmaps()); // 0
     }
     {
         SkCanvas* canvas = recorder.beginRecording(10, 10);
         canvas->drawPicture(childWithBitmap);
-        SkAutoTUnref<SkPicture> parentPWB(recorder.endRecording());
+        sk_sp<SkPicture> parentPWB(recorder.finishRecordingAsPicture());
         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());
+        sk_sp<SkPicture> parentWBP(recorder.finishRecordingAsPicture());
         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());
+        sk_sp<SkPicture> parentWBWB(recorder.finishRecordingAsPicture());
         REPORTER_ASSERT(reporter, parentWBWB->willPlayBackBitmaps()); // 2
     }
 }
 
 static void test_gen_id(skiatest::Reporter* reporter) {
 
     SkPictureRecorder recorder;
     recorder.beginRecording(0, 0);
-    SkAutoTUnref<SkPicture> empty(recorder.endRecording());
+    sk_sp<SkPicture> empty(recorder.finishRecordingAsPicture());
 
     // Empty pictures should still have a valid ID
     REPORTER_ASSERT(reporter, empty->uniqueID() != SK_InvalidGenID);
 
     SkCanvas* canvas = recorder.beginRecording(1, 1);
     canvas->drawARGB(255, 255, 255, 255);
-    SkAutoTUnref<SkPicture> hasData(recorder.endRecording());
+    sk_sp<SkPicture> hasData(recorder.finishRecordingAsPicture());
     // 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());
 }
 
 static void test_typeface(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(10, 10);
     SkPaint paint;
     paint.setTypeface(SkTypeface::CreateFromName("Arial", SkTypeface::kItalic));
     canvas->drawText("Q", 1, 0, 10, paint);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     REPORTER_ASSERT(reporter, picture->hasText());
     SkDynamicMemoryWStream stream;
     picture->serialize(&stream);
 }
 
 DEF_TEST(Picture, reporter) {
     test_typeface(reporter);
 #ifdef SK_DEBUG
     test_deleting_empty_picture();
     test_serializing_empty_picture();
@@ skipping 31 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));
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 }
 
 DEF_TEST(Canvas_EmptyBitmap, r) {
     SkBitmap dst;
     dst.allocN32Pixels(10, 10);
     SkCanvas canvas(dst);
 
     test_draw_bitmaps(&canvas);
 }
 
@@ skipping 22 matching lines @@
 
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(100, 100);
     canvas->drawARGB(0, 0, 0, 0);
 
     canvas->saveLayer(0, &semiTransparent);
     canvas->drawBitmap(blueBM, 25, 25);
     canvas->drawBitmap(redBM, 50, 50);
     canvas->restore();
 
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     // Now replay the picture back on another canvas
     // and check a couple of its pixels.
     SkBitmap replayBM;
     make_bm(&replayBM, 100, 100, SK_ColorBLACK, false);
     SkCanvas replayCanvas(replayBM);
     picture->playback(&replayCanvas);
     replayCanvas.flush();
 
     // With the bug present, at (55, 55) we would get a fully opaque red
@@ skipping 31 matching lines @@
 DEF_TEST(Picture_SkipBBH, r) {
     SkRect bound = SkRect::MakeWH(320, 240);
     CountingBBH bbh(bound);
     SpoonFedBBHFactory factory(&bbh);
 
     SkPictureRecorder recorder;
     SkCanvas* c = recorder.beginRecording(bound, &factory);
     // Record a few ops so we don't hit a small- or empty- picture optimization.
         c->drawRect(bound, SkPaint());
         c->drawRect(bound, SkPaint());
-    SkAutoTUnref<const SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     SkCanvas big(640, 480), small(300, 200);
 
     picture->playback(&big);
     REPORTER_ASSERT(r, bbh.searchCalls == 0);
 
     picture->playback(&small);
     REPORTER_ASSERT(r, bbh.searchCalls == 1);
 }
 
 DEF_TEST(Picture_BitmapLeak, r) {
     SkBitmap mut, immut;
     mut.allocN32Pixels(300, 200);
     immut.allocN32Pixels(300, 200);
     immut.setImmutable();
     SkASSERT(!mut.isImmutable());
     SkASSERT(immut.isImmutable());
 
     // No one can hold a ref on our pixels yet.
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, immut.pixelRef()->unique());
 
-    SkAutoTUnref<const SkPicture> pic;
+    sk_sp<SkPicture> pic;
     {
         // we want the recorder to go out of scope before our subsequent checks, so we
         // place it inside local braces.
         SkPictureRecorder rec;
         SkCanvas* canvas = rec.beginRecording(1920, 1200);
             canvas->drawBitmap(mut, 0, 0);
             canvas->drawBitmap(immut, 800, 600);
-        pic.reset(rec.endRecording());
+        pic = rec.finishRecordingAsPicture();
     }
 
     // The picture shares the immutable pixels but copies the mutable ones.
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, !immut.pixelRef()->unique());
 
     // When the picture goes away, it's just our bitmaps holding the refs.
-    pic.reset(nullptr);
+    pic = nullptr;
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, immut.pixelRef()->unique());
 }
 
 // getRecordingCanvas() should return a SkCanvas when recording, null when not recording.
 DEF_TEST(Picture_getRecordingCanvas, r) {
     SkPictureRecorder rec;
     REPORTER_ASSERT(r, !rec.getRecordingCanvas());
     for (int i = 0; i < 3; i++) {
         rec.beginRecording(100, 100);
         REPORTER_ASSERT(r, rec.getRecordingCanvas());
-        rec.endRecording()->unref();
+        rec.finishRecordingAsPicture();
         REPORTER_ASSERT(r, !rec.getRecordingCanvas());
     }
 }
 
 DEF_TEST(MiniRecorderLeftHanging, r) {
     // Any shader or other ref-counted effect will do just fine here.
     SkPaint paint;
     paint.setShader(SkShader::MakeColorShader(SK_ColorRED));
 
     SkMiniRecorder rec;
     REPORTER_ASSERT(r, rec.drawRect(SkRect::MakeWH(20,30), paint));
     // Don't call rec.detachPicture().  Test succeeds by not asserting or leaking the shader.
 }
 
 DEF_TEST(Picture_preserveCullRect, r) {
     SkPictureRecorder recorder;
 
     SkCanvas* c = recorder.beginRecording(SkRect::MakeLTRB(1, 2, 3, 4));
     c->clear(SK_ColorCYAN);
 
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     SkDynamicMemoryWStream wstream;
     picture->serialize(&wstream);
 
     SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
-    SkAutoTUnref<SkPicture> deserializedPicture(SkPicture::CreateFromStream(rstream));
+    sk_sp<SkPicture> deserializedPicture(SkPicture::MakeFromStream(rstream));
 
     REPORTER_ASSERT(r, deserializedPicture != nullptr);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().left() == 1);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().top() == 2);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().right() == 3);
     REPORTER_ASSERT(r, deserializedPicture->cullRect().bottom() == 4);
 }