update callsites for Make image factories

samplecode/SampleFilterQuality.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 "Resources.h"
@@ skipping 10 matching lines @@
 
 static SkSurface* make_surface(SkCanvas* canvas, const SkImageInfo& info) {
     SkSurface* surface = canvas->newSurface(info);
     if (!surface) {
         surface = SkSurface::NewRaster(info);
     }
     return surface;
 }
 
 static sk_sp<SkShader> make_shader(const SkRect& bounds) {
-#if 0
-    const SkPoint pts[] = {
-        { bounds.left(), bounds.top() },
-        { bounds.right(), bounds.bottom() },
-    };
-    const SkColor colors[] = {
-        SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorBLACK,
-        SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW,
-    };
-    return SkGradientShader::CreateLinear(pts,
-                                          colors, nullptr, SK_ARRAY_COUNT(colors),
-                                          SkShader::kClamp_TileMode);
-#else
-    SkAutoTUnref<SkImage> image(GetResourceAsImage("mandrill_128.png"));
-    if (nullptr == image) {
+    sk_sp<SkImage> image(GetResourceAsImage("mandrill_128.png"));
+    if (!image) {
         return nullptr;
     }
     return image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
-#endif
 }
 
 #define N   128
 #define ANGLE_DELTA 3
 #define SCALE_DELTA (SK_Scalar1 / 32)
 
-static SkImage* make_image() {
+static sk_sp<SkImage> make_image() {
     SkImageInfo info = SkImageInfo::MakeN32(N, N, kOpaque_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
     SkCanvas* canvas = surface->getCanvas();
     canvas->drawColor(SK_ColorWHITE);
 
     SkPath path;
     path.setFillType(SkPath::kEvenOdd_FillType);
 
     path.addRect(SkRect::MakeWH(N/2, N));
     path.addRect(SkRect::MakeWH(N, N/2));
     path.moveTo(0, 0); path.lineTo(N, 0); path.lineTo(0, N); path.close();
 
     SkPaint paint;
     paint.setShader(make_shader(SkRect::MakeWH(N, N)));
     
     canvas->drawPath(path, paint);
-    return surface->newImageSnapshot();
+    return surface->makeImageSnapshot();
 }
 
-static SkImage* zoom_up(SkSurface* origSurf, SkImage* orig) {
+static sk_sp<SkImage> zoom_up(SkSurface* origSurf, SkImage* orig) {
     const SkScalar S = 16;    // amount to scale up
     const int D = 2;    // dimension scaling for the offscreen
     // since we only view the center, don't need to produce the entire thing
     
     SkImageInfo info = SkImageInfo::MakeN32(orig->width() * D, orig->height() * D,
                                             kOpaque_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(origSurf->newSurface(info));
     SkCanvas* canvas = surface->getCanvas();
     canvas->drawColor(SK_ColorWHITE);
     canvas->scale(S, S);
     canvas->translate(-SkScalarHalf(orig->width()) * (S - D) / S,
                       -SkScalarHalf(orig->height()) * (S - D) / S);
     canvas->drawImage(orig, 0, 0, nullptr);
     
     if (S > 3) {
         SkPaint paint;
         paint.setColor(SK_ColorWHITE);
         for (int i = 1; i < orig->height(); ++i) {
             SkScalar y = SkIntToScalar(i);
             canvas->drawLine(0, y, SkIntToScalar(orig->width()), y, paint);
         }
         for (int i = 1; i < orig->width(); ++i) {
             SkScalar x = SkIntToScalar(i);
             canvas->drawLine(x, 0, x, SkIntToScalar(orig->height()), paint);
         }
     }
-    return surface->newImageSnapshot();
+    return surface->makeImageSnapshot();
 }
 
 struct AnimValue {
     SkScalar fValue;
     SkScalar fMin;
     SkScalar fMax;
     SkScalar fMod;
 
     operator SkScalar() const { return fValue; }
 
@@ skipping 35 matching lines @@
     p.setStyle(SkPaint::kStroke_Style);
     p.setColor(SK_ColorRED);
     SkRect r = SkRect::MakeIWH(width, height);
     r.inset(0.5f, 0.5f);
     canvas->drawRect(r, p);
     canvas->drawLine(r.left(), r.top(), r.right(), r.bottom(), p);
     canvas->drawLine(r.left(), r.bottom(), r.right(), r.top(), p);
 }
 
 class FilterQualityView : public SampleView {
-    SkAutoTUnref<SkImage> fImage;
-    AnimValue             fScale, fAngle;
-    SkSize              fCell;
-    SkInterpolator      fTrans;
-    SkMSec              fCurrTime;
-    bool                fShowFatBits;
+    sk_sp<SkImage>  fImage;
+    AnimValue       fScale, fAngle;
+    SkSize          fCell;
+    SkInterpolator  fTrans;
+    SkMSec          fCurrTime;
+    bool            fShowFatBits;
 
 public:
     FilterQualityView() : fImage(make_image()), fTrans(2, 2), fShowFatBits(true) {
         fCell.set(256, 256);
 
         fScale.set(1, SK_Scalar1 / 8, 1);
         fAngle.setMod(0, 360);
 
         SkScalar values[2];
         fTrans.setMirror(true);
@@ skipping 34 matching lines @@
         paint.setAntiAlias(true);
         paint.setFilterQuality(filter);
 
         SkAutoCanvasRestore acr(canvas, true);
 
         canvas->translate(dx, dy);
 
         canvas->translate(SkScalarHalf(size.width()), SkScalarHalf(size.height()));
         canvas->scale(fScale, fScale);
         canvas->rotate(fAngle);
-        canvas->drawImage(fImage, -SkScalarHalf(fImage->width()), -SkScalarHalf(fImage->height()),
+        canvas->drawImage(fImage.get(), -SkScalarHalf(fImage->width()), -SkScalarHalf(fImage->height()),
                           &paint);
 
         if (false) {
             acr.restore();
             draw_box_frame(canvas, size.width(), size.height());
         }
     }
 
     void drawHere(SkCanvas* canvas, SkFilterQuality filter, SkScalar dx, SkScalar dy) {
         SkCanvas* origCanvas = canvas;
@@ skipping 10 matching lines @@
             canvas = surface->getCanvas();
             canvas->drawColor(SK_ColorWHITE);
             size.set(info.width(), info.height());
         } else {
             canvas->translate(SkScalarHalf(fCell.width() - fImage->width()),
                               SkScalarHalf(fCell.height() - fImage->height()));
         }
         this->drawTheImage(canvas, size, filter, dx, dy);
 
         if (surface) {
-            SkAutoTUnref<SkImage> orig(surface->newImageSnapshot());
-            SkAutoTUnref<SkImage> zoomed(zoom_up(surface, orig));
-            origCanvas->drawImage(zoomed,
+            sk_sp<SkImage> orig(surface->makeImageSnapshot());
+            sk_sp<SkImage> zoomed(zoom_up(surface, orig.get()));
+            origCanvas->drawImage(zoomed.get(),
                                   SkScalarHalf(fCell.width() - zoomed->width()),
                                   SkScalarHalf(fCell.height() - zoomed->height()));
         }
     }
 
     void drawBorders(SkCanvas* canvas) {
         SkPaint p;
         p.setStyle(SkPaint::kStroke_Style);
         p.setColor(SK_ColorBLUE);
 
@@ skipping 52 matching lines @@
     }
 
 private:
     typedef SampleView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new FilterQualityView; }
 static SkViewRegister reg(MyFactory);