update callsites for Make image factories

gm/bleed.cpp

 /*
  * Copyright 2013 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 "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
 #include "SkUtils.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextOptions.h"
 #include "SkGr.h"
 #endif
 
 /** Holds either a bitmap or image to be rendered and a rect that indicates what part of the bitmap
     or image should be tested by the GM. The area outside of the rect is present to check
     for bleed due to filtering/blurring. */
 struct TestPixels {
     enum Type {
         kBitmap,
         kImage
     };
-    Type                  fType;
-    SkBitmap              fBitmap;
-    SkAutoTUnref<SkImage> fImage;
-    SkIRect               fRect;  // The region of the bitmap/image that should be rendered.
+    Type            fType;
+    SkBitmap        fBitmap;
+    sk_sp<SkImage>  fImage;
+    SkIRect         fRect;  // The region of the bitmap/image that should be rendered.
 };
 
 /** Creates a bitmap with two one-pixel rings around a checkerboard. The checkerboard is 2x2
     logically where each check has as many pixels as is necessary to fill the interior. The rect
     to draw is set to the checkerboard portion. */
 template<typename PIXEL_TYPE>
 bool make_ringed_bitmap(GrContext*, TestPixels* result, int width, int height,
                         SkColorType ct, SkAlphaType at,
                         PIXEL_TYPE outerRingColor, PIXEL_TYPE innerRingColor,
                         PIXEL_TYPE checkColor1, PIXEL_TYPE checkColor2) {
@@ skipping 79 matching lines @@
     static const uint8_t kHalf = 0x80;
     static const uint8_t k3Q   = 0xC0;
     static const uint8_t kOne  = 0xFF;
     return make_ringed_bitmap<uint8_t>(ctx, result, width, height, kAlpha_8_SkColorType,
                                        kPremul_SkAlphaType, kZero, kOne, k3Q, kHalf);
 }
 
 /** Helper to reuse above functions to produce images rather than bmps */
 static void bmp_to_image(TestPixels* result) {
     SkASSERT(TestPixels::kBitmap == result->fType);
-    result->fImage.reset(SkImage::NewFromBitmap(result->fBitmap));
+    result->fImage = SkImage::MakeFromBitmap(result->fBitmap);
     SkASSERT(result->fImage);
     result->fType = TestPixels::kImage;
     result->fBitmap.reset();
 }
 
 /** Color image case. */
 bool make_ringed_color_image(GrContext* ctx, TestPixels* result, int width, int height) {
     if (make_ringed_color_bitmap(ctx, result, width, height)) {
         bmp_to_image(result);
         return true;
@@ skipping 194 matching lines @@
     SkISize onISize() override {
         return SkISize::Make(1200, 1080);
     }
 
     void drawPixels(SkCanvas* canvas, const TestPixels& pixels, const SkRect& src,
                     const SkRect& dst, const SkPaint* paint,
                     SkCanvas::SrcRectConstraint constraint) {
         if (TestPixels::kBitmap == pixels.fType) {
             canvas->drawBitmapRect(pixels.fBitmap, src, dst, paint, constraint);
         } else {
-            canvas->drawImageRect(pixels.fImage, src, dst, paint, constraint);
+            canvas->drawImageRect(pixels.fImage.get(), src, dst, paint, constraint);
         }
     }
 
     // Draw the area of interest of the small image
     void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa,
                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
 
         SkRect src = SkRect::Make(fSmallTestPixels.fRect);
         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
@@ skipping 237 matching lines @@
 
 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseTextureBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseImage_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaTextureBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaTextureBitmapShader_BleedTest); )
 DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); )