return pictures as sk_sp

gm/image.cpp

 /*
  * Copyright 2011 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 "gm.h"
 #include "SkAutoPixmapStorage.h"
@@ skipping 228 matching lines @@
 
 static sk_sp<SkImage> make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
     draw(surface->getCanvas());
     return surface->makeImageSnapshot();
 }
 
 static sk_sp<SkImage> make_picture(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
     SkPictureRecorder recorder;
     draw(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height())));
-    SkAutoTUnref<SkPicture> pict(recorder.endRecording());
-    return SkImage::MakeFromPicture(sk_ref_sp(pict.get()), info.dimensions(), nullptr, nullptr);
+    return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
+                                    info.dimensions(), nullptr, nullptr);
 }
 
 static sk_sp<SkImage> make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
     sk_sp<SkImage> image(make_raster(info, nullptr, draw));
     sk_sp<SkData> data(image->encode());
     return SkImage::MakeFromEncoded(data);
 }
 
 static sk_sp<SkImage> make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) {
     if (!ctx) { return nullptr; }
@@ skipping 75 matching lines @@
 
 static SkImageGenerator* gen_raster(const SkImageInfo& info) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
     draw_opaque_contents(surface->getCanvas());
     return new ImageGeneratorFromImage(surface->makeImageSnapshot().get());
 }
 
 static SkImageGenerator* gen_picture(const SkImageInfo& info) {
     SkPictureRecorder recorder;
     draw_opaque_contents(recorder.beginRecording(SkRect::MakeIWH(info.width(), info.height())));
-    SkAutoTUnref<SkPicture> pict(recorder.endRecording());
-    return SkImageGenerator::NewFromPicture(info.dimensions(), pict, nullptr, nullptr);
+    sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
+    return SkImageGenerator::NewFromPicture(info.dimensions(), pict.get(), nullptr, nullptr);
 }
 
 static SkImageGenerator* gen_png(const SkImageInfo& info) {
     sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents));
     SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100));
     return SkImageGenerator::NewFromEncoded(data);
 }
 
 static SkImageGenerator* gen_jpg(const SkImageInfo& info) {
     sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents));
@@ skipping 111 matching lines @@
         [bmp] {
             sk_sp<SkData> src(
                 SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100));
             return SkImage::MakeFromEncoded(std::move(src));
         },
         // Create a picture image.
         [render_image] {
             SkPictureRecorder recorder;
             SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize));
             render_image(canvas);
-            SkAutoTUnref<SkPicture> picture(recorder.endRecording());
-            return SkImage::MakeFromPicture(sk_ref_sp(picture.get()), SkISize::Make(kSize, kSize),
-                                            nullptr, nullptr);
+            return SkImage::MakeFromPicture(recorder.finishRecordingAsPicture(),
+                                           SkISize::Make(kSize, kSize), nullptr, nullptr);
         },
         // Create a texture image
         [context, render_image]() -> sk_sp<SkImage> {
             SkAutoTUnref<SkSurface> surface(
                 SkSurface::NewRenderTarget(context, SkBudgeted::kYes,
                                            SkImageInfo::MakeN32Premul(kSize, kSize)));
             if (!surface) {
                 return nullptr;
             }
             render_image(surface->getCanvas());
@@ skipping 10 matching lines @@
         }
         if (context) {
             sk_sp<SkImage> texImage(image->makeTextureImage(context));
             if (texImage) {
                 canvas->drawImage(texImage, 0, 0);
             }
         }
         canvas->translate(image->width() + kPad, 0);
     }
 }