update callsites for Make image factories

gm/drawminibitmaprect.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 "gm.h"
 #include "SkColorPriv.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkSurface.h"
 
-static SkImage* makebm(SkCanvas* caller, int w, int h) {
+static sk_sp<SkImage> makebm(SkCanvas* caller, int w, int h) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
     SkAutoTUnref<SkSurface> surface(caller->newSurface(info));
     if (nullptr == surface) {
         surface.reset(SkSurface::NewRaster(info));
     }
     SkCanvas* canvas = surface->getCanvas();
 
     const SkScalar wScalar = SkIntToScalar(w);
     const SkScalar hScalar = SkIntToScalar(h);
 
@@ skipping 22 matching lines @@
         paint.setShader(SkGradientShader::MakeRadial(
                         pt, radius,
                         colors, pos,
                         SK_ARRAY_COUNT(colors),
                         SkShader::kRepeat_TileMode,
                         0, &mat));
         canvas->drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
         mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
     }
-    return surface->newImageSnapshot();
+    return surface->makeImageSnapshot();
 }
 
 static const int gSize = 1024;
 static const int gSurfaceSize = 2048;
 
 // This GM calls drawImageRect several times using the same texture. This is
 // intended to exercise batching of these calls.
 class DrawMiniBitmapRectGM : public skiagm::GM {
 public:
     DrawMiniBitmapRectGM(bool antiAlias) : fAA(antiAlias) {
         fName.set("drawminibitmaprect");
         if (fAA) {
             fName.appendf("_aa");
         }
     }
 
 protected:
     SkString onShortName() override { return fName; }
 
     SkISize onISize() override { return SkISize::Make(gSize, gSize); }
 
     void onDraw(SkCanvas* canvas) override {
         if (nullptr == fImage) {
-            fImage.reset(makebm(canvas, gSurfaceSize, gSurfaceSize));
+            fImage = makebm(canvas, gSurfaceSize, gSurfaceSize);
         }
 
         const SkRect dstRect = { 0, 0, SkIntToScalar(64), SkIntToScalar(64)};
         static const int kMaxSrcRectSize = 1 << (SkNextLog2(gSurfaceSize) + 2);
 
         static const int kPadX = 30;
         static const int kPadY = 40;
 
         int rowCount = 0;
         canvas->translate(SkIntToScalar(kPadX), SkIntToScalar(kPadY));
@@ skipping 12 matching lines @@
                     case 0:
                         canvas->rotate(random.nextF() * 10.f);
                         break;
                     case 1:
                         canvas->rotate(-random.nextF() * 10.f);
                         break;
                     case 2:
                         // rect stays rect
                         break;
                 }
-                canvas->drawImageRect(fImage, srcRect, dstRect, &paint,
+                canvas->drawImageRect(fImage.get(), srcRect, dstRect, &paint,
                                       SkCanvas::kFast_SrcRectConstraint);
                 canvas->restore();
 
                 canvas->translate(dstRect.width() + SK_Scalar1 * kPadX, 0);
                 ++rowCount;
                 if ((dstRect.width() + 2 * kPadX) * rowCount > gSize) {
                     canvas->restore();
                     canvas->translate(0, dstRect.height() + SK_Scalar1 * kPadY);
                     canvas->save();
                     rowCount = 0;
                 }
             }
         }
         canvas->restore();
     }
 
 private:
-    bool                  fAA;
-    SkAutoTUnref<SkImage> fImage;
-    SkString              fName;
+    bool            fAA;
+    sk_sp<SkImage>  fImage;
+    SkString        fName;
 
     typedef skiagm::GM INHERITED;
 };
 
 DEF_GM( return new DrawMiniBitmapRectGM(true); )
 DEF_GM( return new DrawMiniBitmapRectGM(false); )