switch surface to 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 149 matching lines @@
         canvas->drawText(kLabel8, strlen(kLabel8),  80, 10, textPaint);
         canvas->drawText(kLabel9, strlen(kLabel9), 160, 10, textPaint);
         canvas->drawText(kLabel10, strlen(kLabel10), 265, 10, textPaint);
 
         canvas->translate(80, 20);
 
         // since we draw into this directly, we need to start fresh
         sk_bzero(fBuffer, fBufferSize);
 
         SkImageInfo info = SkImageInfo::MakeN32Premul(W, H);
-        SkAutoTUnref<SkSurface> surf0(SkSurface::NewRasterDirect(info, fBuffer, RB));
-        SkAutoTUnref<SkSurface> surf1(SkSurface::NewRaster(info));
-        SkAutoTUnref<SkSurface> surf2;  // gpu
+        sk_sp<SkSurface> surf0(SkSurface::MakeRasterDirect(info, fBuffer, RB));
+        sk_sp<SkSurface> surf1(SkSurface::MakeRaster(info));
+        sk_sp<SkSurface> surf2;  // gpu
 
 #if SK_SUPPORT_GPU
-        surf2.reset(SkSurface::NewRenderTarget(canvas->getGrContext(),
-                                               SkBudgeted::kNo, info));
+        surf2 = SkSurface::MakeRenderTarget(canvas->getGrContext(), SkBudgeted::kNo, info);
 #endif
 
-        test_surface(canvas, surf0, true);
+        test_surface(canvas, surf0.get(), true);
         canvas->translate(80, 0);
-        test_surface(canvas, surf1, true);
+        test_surface(canvas, surf1.get(), true);
         if (surf2) {
             canvas->translate(80, 0);
-            test_surface(canvas, surf2, true);
+            test_surface(canvas, surf2.get(), true);
         }
     }
 
 private:
     typedef skiagm::GM INHERITED;
 };
 DEF_GM( return new ImageGM; )
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 36 matching lines @@
 }
 
 static void draw_contents(SkCanvas* canvas) {
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(20);
     canvas->drawCircle(50, 50, 35, paint);
 }
 
 static sk_sp<SkImage> make_raster(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
+    auto surface(SkSurface::MakeRaster(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())));
     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; }
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info));
+    auto surface(SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info));
     draw(surface->getCanvas());
     return surface->makeImageSnapshot();
 }
 
 typedef sk_sp<SkImage> (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*));
 
 class ScalePixelsGM : public skiagm::GM {
 public:
     ScalePixelsGM() {}
 
@@ skipping 56 matching lines @@
 static void draw_opaque_contents(SkCanvas* canvas) {
     canvas->drawColor(0xFFFF8844);
 
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(20);
     canvas->drawCircle(50, 50, 35, paint);
 }
 
 static SkImageGenerator* gen_raster(const SkImageInfo& info) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
+    auto surface(SkSurface::MakeRaster(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())));
     sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture());
     return SkImageGenerator::NewFromPicture(info.dimensions(), pict.get(), nullptr, nullptr);
 }
@@ skipping 125 matching lines @@
         // Create a picture image.
         [render_image] {
             SkPictureRecorder recorder;
             SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize));
             render_image(canvas);
             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)));
+            auto surface(
+                SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
+                                            SkImageInfo::MakeN32Premul(kSize, kSize)));
             if (!surface) {
                 return nullptr;
             }
             render_image(surface->getCanvas());
             return surface->makeImageSnapshot();
         }
     };
 
     static const SkScalar kPad = 5.f;
     canvas->translate(kPad, kPad);
     for (auto factory : imageFactories) {
         auto image(factory());
         if (!image) {
             continue;
         }
         if (context) {
             sk_sp<SkImage> texImage(image->makeTextureImage(context));
             if (texImage) {
                 canvas->drawImage(texImage, 0, 0);
             }
         }
         canvas->translate(image->width() + kPad, 0);
     }
 }