return pictures as sk_sp

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
 #include "DMGpuSupport.h"
@@ skipping 93 matching lines @@
 static sk_sp<SkImage> create_data_image() {
     SkImageInfo info;
     sk_sp<SkData> data(create_image_data(&info));
     return SkImage::MakeRasterData(info, data, info.minRowBytes());
 }
 #if SK_SUPPORT_GPU // not gpu-specific but currently only used in GPU tests
 static sk_sp<SkImage> create_picture_image() {
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(10, 10);
     canvas->clear(SK_ColorCYAN);
-    sk_sp<SkPicture> picture(recorder.endRecording());
-    return SkImage::MakeFromPicture(picture, SkISize::Make(10, 10), nullptr, nullptr);
+    return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(), SkISize::Make(10, 10),
+                                    nullptr, nullptr);
 };
 #endif
 // Want to ensure that our Release is called when the owning image is destroyed
 struct RasterDataHolder {
     RasterDataHolder() : fReleaseCount(0) {}
     SkAutoTUnref<SkData> fData;
     int fReleaseCount;
     static void Release(const void* pixels, void* context) {
         RasterDataHolder* self = static_cast<RasterDataHolder*>(context);
         self->fReleaseCount++;
@@ skipping 99 matching lines @@
 // Test that image encoding failures do not break picture serialization/deserialization.
 DEF_TEST(Image_Serialize_Encoding_Failure, reporter) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
     surface->getCanvas()->clear(SK_ColorGREEN);
     sk_sp<SkImage> image(surface->makeImageSnapshot());
     REPORTER_ASSERT(reporter, image);
 
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(100, 100);
     canvas->drawImage(image, 0, 0);
-    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+    sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
     REPORTER_ASSERT(reporter, picture);
     REPORTER_ASSERT(reporter, picture->approximateOpCount() > 0);
 
     MockSerializer emptySerializer([]() -> SkData* { return SkData::NewEmpty(); });
     MockSerializer nullSerializer([]() -> SkData* { return nullptr; });
     MockSerializer* serializers[] = { &emptySerializer, &nullSerializer };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(serializers); ++i) {
         SkDynamicMemoryWStream wstream;
         REPORTER_ASSERT(reporter, !serializers[i]->didEncode());
         picture->serialize(&wstream, serializers[i]);
         REPORTER_ASSERT(reporter, serializers[i]->didEncode());
 
         SkAutoTDelete<SkStream> rstream(wstream.detachAsStream());
-        SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rstream));
+        sk_sp<SkPicture> deserialized(SkPicture::MakeFromStream(rstream));
         REPORTER_ASSERT(reporter, deserialized);
         REPORTER_ASSERT(reporter, deserialized->approximateOpCount() > 0);
     }
 }
 
 DEF_TEST(Image_NewRasterCopy, reporter) {
     const SkPMColor red =   SkPackARGB32(0xFF, 0xFF, 0, 0);
     const SkPMColor green = SkPackARGB32(0xFF, 0, 0xFF, 0);
     const SkPMColor blue =  SkPackARGB32(0xFF, 0, 0, 0xFF);
     SkPMColor colors[] = { red, green, blue, 0 };
@@ skipping 623 matching lines @@
                         otherContextInfo.fGrContext, buffer, budgeted));
                     REPORTER_ASSERT(reporter, !newImage2);
                     glContext->makeCurrent();
                 }
             }
             sk_free(buffer);
         }
     }
 }
 #endif