Update LightingImageFilter to sk_sp

TBR=reed@google.com

GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1869763002

Review URL: https://codereview.chromium.org/1869763002

4 files changed, 110 insertions, 110 deletions

diff --git a/gm/imagefiltersclipped.cpp b/gm/imagefiltersclipped.cpp
index b24ca5af72..f2434112fa 100644
--- a/gm/imagefiltersclipped.cpp
+++ b/gm/imagefiltersclipped.cpp
@@ -43,11 +43,11 @@ static sk_sp<SkImage> make_gradient_circle(int width, int height) {
     return surface->makeImageSnapshot();
 }
 
-static void draw_clipped_filter(SkCanvas* canvas, SkImageFilter* filter, size_t i,
+static void draw_clipped_filter(SkCanvas* canvas, sk_sp<SkImageFilter> filter, size_t i,
                                 const SkRect& primBounds, const SkRect& clipBounds) {
     SkPaint paint;
     paint.setColor(SK_ColorWHITE);
-    paint.setImageFilter(filter);
+    paint.setImageFilter(std::move(filter));
     paint.setAntiAlias(true);
     canvas->save();
     canvas->clipRect(clipBounds);
@@ -93,23 +93,25 @@ protected:
         resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
         SkPoint3 pointLocation = SkPoint3::Make(32, 32, SkIntToScalar(10));
 
-        SkImageFilter* filters[] = {
-            SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr).release(),
-            SkDropShadowImageFilter::Make(SkIntToScalar(10), SkIntToScalar(10),
-                SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
-                nullptr).release(),
-            SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+        sk_sp<SkImageFilter> filters[] = {
+            SkBlurImageFilter::Make(SkIntToScalar(12), SkIntToScalar(12), nullptr),
+            SkDropShadowImageFilter::Make(
+                                    SkIntToScalar(10), SkIntToScalar(10),
+                                    SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
+                                    SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+                                    nullptr),
+            sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
+                                            SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkIntToScalar(12),
                                             gradient.get(),
-                                            checkerboard.get()),
-            SkDilateImageFilter::Make(2, 2, checkerboard).release(),
-            SkErodeImageFilter::Make(2, 2, checkerboard).release(),
-            SkOffsetImageFilter::Make(SkIntToScalar(-16), SkIntToScalar(32), nullptr).release(),
-            SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr).release(),
-            SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, SK_ColorWHITE, SK_Scalar1,
-                                                         SkIntToScalar(2), checkerboard.get()),
+                                            checkerboard.get())),
+            SkDilateImageFilter::Make(2, 2, checkerboard),
+            SkErodeImageFilter::Make(2, 2, checkerboard),
+            SkOffsetImageFilter::Make(SkIntToScalar(-16), SkIntToScalar(32), nullptr),
+            SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr),
+            SkLightingImageFilter::MakePointLitDiffuse(pointLocation, SK_ColorWHITE, SK_Scalar1,
+                                                       SkIntToScalar(2), checkerboard),
 
         };
 
@@ -131,10 +133,6 @@ protected:
         }
         canvas->restore();
 
-        for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
-            SkSafeUnref(filters[i]);
-        }
-
         SkPaint noisePaint;
         noisePaint.setShader(SkPerlinNoiseShader::MakeFractalNoise(0.1f, 0.05f, 1, 0));
 
@@ -142,7 +140,7 @@ protected:
         canvas->translate(SK_ARRAY_COUNT(filters)*(r.width() + margin), 0);
         for (int xOffset = 0; xOffset < 80; xOffset += 16) {
             bounds.fLeft = SkIntToScalar(xOffset);
-            draw_clipped_filter(canvas, rectFilter.get(), 0, r, bounds);
+            draw_clipped_filter(canvas, rectFilter, 0, r, bounds);
             canvas->translate(0, r.height() + margin);
         }
     }
diff --git a/gm/imagefilterscropexpand.cpp b/gm/imagefilterscropexpand.cpp
index 6f749dc7e5..3d5fcf3612 100644
--- a/gm/imagefilterscropexpand.cpp
+++ b/gm/imagefilterscropexpand.cpp
@@ -55,7 +55,7 @@ protected:
                                 0, 1, 0, 0, sk255,
                                 0, 0, 1, 0, 0,
                                 0, 0, 0, 0, sk255 };
-        auto cfAlphaTrans(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+        sk_sp<SkColorFilter> cfAlphaTrans(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
 
         SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
         SkScalar MARGIN = SkIntToScalar(12);
@@ -121,12 +121,12 @@ protected:
                                            &bigRect));
 
             Draw(canvas, checkerboard, rect,
-                 sk_sp<SkImageFilter>(SkLightingImageFilter::CreatePointLitDiffuse(pointLocation,
-                                                                                   SK_ColorWHITE,
-                                                                                   surfaceScale,
-                                                                                   kd,
-                                                                                   noopCropped.get(),
-                                                                                   &bigRect)));
+                 SkLightingImageFilter::MakePointLitDiffuse(pointLocation,
+                                                            SK_ColorWHITE,
+                                                            surfaceScale,
+                                                            kd,
+                                                            noopCropped,
+                                                            &bigRect));
 
             canvas->restore();
             canvas->translate(0, SkIntToScalar(80));
diff --git a/gm/imagefiltersscaled.cpp b/gm/imagefiltersscaled.cpp
index 46f998cc28..4c48aec869 100644
--- a/gm/imagefiltersscaled.cpp
+++ b/gm/imagefiltersscaled.cpp
@@ -25,6 +25,25 @@
 
 #define RESIZE_FACTOR SkIntToScalar(4)
 
+static sk_sp<SkImage> make_gradient_circle(int width, int height) {
+    SkScalar x = SkIntToScalar(width / 2);
+    SkScalar y = SkIntToScalar(height / 2);
+    SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
+    sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(width, height));
+    SkCanvas* canvas = surface->getCanvas();
+    canvas->clear(0x00000000);
+    SkColor colors[2];
+    colors[0] = SK_ColorWHITE;
+    colors[1] = SK_ColorBLACK;
+    SkPaint paint;
+    paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
+        2, SkShader::kClamp_TileMode));
+    canvas->drawCircle(x, y, radius, paint);
+
+    return surface->makeImageSnapshot();
+}
+
+
 namespace skiagm {
 
 class ImageFiltersScaledGM : public GM {
@@ -46,7 +65,7 @@ protected:
     void onOnceBeforeDraw() override {
         fCheckerboard = SkImage::MakeFromBitmap(
             sk_tool_utils::create_checkerboard_bitmap(64, 64, 0xFFA0A0A0, 0xFF404040, 8));
-        fGradientCircle = MakeGradientCircle(64, 64);
+        fGradientCircle = make_gradient_circle(64, 64);
     }
 
     void onDraw(SkCanvas* canvas) override {
@@ -54,10 +73,10 @@ protected:
 
         sk_sp<SkImageFilter> gradient(SkImageSource::Make(fGradientCircle));
         sk_sp<SkImageFilter> checkerboard(SkImageSource::Make(fCheckerboard));
-        sk_sp<SkShader> noise(SkPerlinNoiseShader::MakeFractalNoise(
-            SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
+
         SkPaint noisePaint;
-        noisePaint.setShader(noise);
+        noisePaint.setShader(SkPerlinNoiseShader::MakeFractalNoise(SkDoubleToScalar(0.1),
+                                                                   SkDoubleToScalar(0.05), 1, 0));
 
         SkPoint3 pointLocation = SkPoint3::Make(0, 0, SkIntToScalar(10));
         SkPoint3 spotLocation = SkPoint3::Make(SkIntToScalar(-10),
@@ -72,24 +91,29 @@ protected:
         SkMatrix resizeMatrix;
         resizeMatrix.setScale(RESIZE_FACTOR, RESIZE_FACTOR);
 
-        SkImageFilter* filters[] = {
-            SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr).release(),
-            SkDropShadowImageFilter::Make(SkIntToScalar(5), SkIntToScalar(10),
-                SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
-                SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode, nullptr).release(),
-            SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
+        sk_sp<SkImageFilter> filters[] = {
+            SkBlurImageFilter::Make(SkIntToScalar(4), SkIntToScalar(4), nullptr),
+            SkDropShadowImageFilter::Make(
+                                    SkIntToScalar(5), SkIntToScalar(10),
+                                    SkIntToScalar(3), SkIntToScalar(3), SK_ColorYELLOW,
+                                    SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
+                                    nullptr),
+            sk_sp<SkImageFilter>(SkDisplacementMapEffect::Create(
+                                            SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkIntToScalar(12),
                                             gradient.get(),
-                                            checkerboard.get()),
-            SkDilateImageFilter::Make(1, 1, checkerboard).release(),
-            SkErodeImageFilter::Make(1, 1, checkerboard).release(),
-            SkOffsetImageFilter::Make(SkIntToScalar(32), 0, nullptr).release(),
-            SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr).release(),
-            SkPaintImageFilter::Make(noisePaint).release(),
-            SkLightingImageFilter::CreatePointLitDiffuse(pointLocation, white, surfaceScale, kd),
-            SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
-                                                        cutoffAngle, white, surfaceScale, kd),
+                                            checkerboard.get())),
+            SkDilateImageFilter::Make(1, 1, checkerboard),
+            SkErodeImageFilter::Make(1, 1, checkerboard),
+            SkOffsetImageFilter::Make(SkIntToScalar(32), 0, nullptr),
+            SkImageFilter::MakeMatrixFilter(resizeMatrix, kNone_SkFilterQuality, nullptr),
+            SkPaintImageFilter::Make(noisePaint),
+            SkLightingImageFilter::MakePointLitDiffuse(pointLocation, white, surfaceScale, kd,
+                                                       nullptr),
+            SkLightingImageFilter::MakeSpotLitDiffuse(spotLocation, spotTarget, spotExponent,
+                                                      cutoffAngle, white, surfaceScale, kd,
+                                                      nullptr),
         };
 
         SkVector scales[] = {
@@ -128,31 +152,9 @@ protected:
             canvas->restore();
             canvas->translate(0, r.height() * scales[j].fY + margin);
         }
-
-        for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
-            filters[i]->unref();
-        }
     }
 
 private:
-    static sk_sp<SkImage> MakeGradientCircle(int width, int height) {
-        SkScalar x = SkIntToScalar(width / 2);
-        SkScalar y = SkIntToScalar(height / 2);
-        SkScalar radius = SkScalarMul(SkMinScalar(x, y), SkIntToScalar(4) / SkIntToScalar(5));
-        auto surface(SkSurface::MakeRasterN32Premul(width, height));
-        SkCanvas* canvas = surface->getCanvas();
-        canvas->clear(0x00000000);
-        SkColor colors[2];
-        colors[0] = SK_ColorWHITE;
-        colors[1] = SK_ColorBLACK;
-        SkPaint paint;
-        paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(x, y), radius, colors, nullptr,
-                                                     2, SkShader::kClamp_TileMode));
-        canvas->drawCircle(x, y, radius, paint);
-
-        return surface->makeImageSnapshot();
-    }
-
     sk_sp<SkImage> fCheckerboard, fGradientCircle;
 
     typedef GM INHERITED;
diff --git a/gm/lighting.cpp b/gm/lighting.cpp
index 08d09c2ecb..7915c331d0 100644
--- a/gm/lighting.cpp
+++ b/gm/lighting.cpp
@@ -93,64 +93,64 @@ protected:
         int y = 0;
         for (int i = 0; i < 3; i++) {
             const SkImageFilter::CropRect* cr = (i == 1) ? &cropRect : (i == 2) ? &fullSizeCropRect : nullptr;
-            SkImageFilter* input = (i == 2) ? noopCropped.get() : nullptr;
-            paint.setImageFilter(SkLightingImageFilter::CreatePointLitDiffuse(pointLocation,
+            sk_sp<SkImageFilter> input = (i == 2) ? noopCropped : nullptr;
+            paint.setImageFilter(SkLightingImageFilter::MakePointLitDiffuse(pointLocation,
+                                                                            white,
+                                                                            surfaceScale,
+                                                                            kd,
+                                                                            input,
+                                                                            cr));
+            drawClippedBitmap(canvas, paint, 0, y);
+
+            paint.setImageFilter(SkLightingImageFilter::MakeDistantLitDiffuse(distantDirection,
                                                                               white,
                                                                               surfaceScale,
                                                                               kd,
                                                                               input,
-                                                                              cr))->unref();
-            drawClippedBitmap(canvas, paint, 0, y);
-
-            paint.setImageFilter(SkLightingImageFilter::CreateDistantLitDiffuse(distantDirection,
-                                                                                white,
-                                                                                surfaceScale,
-                                                                                kd,
-                                                                                input,
-                                                                                cr))->unref();
+                                                                              cr));
             drawClippedBitmap(canvas, paint, 110, y);
 
-            paint.setImageFilter(SkLightingImageFilter::CreateSpotLitDiffuse(spotLocation,
-                                                                             spotTarget,
-                                                                             spotExponent,
-                                                                             cutoffAngle,
-                                                                             white,
-                                                                             surfaceScale,
-                                                                             kd,
-                                                                             input,
-                                                                             cr))->unref();
+            paint.setImageFilter(SkLightingImageFilter::MakeSpotLitDiffuse(spotLocation,
+                                                                           spotTarget,
+                                                                           spotExponent,
+                                                                           cutoffAngle,
+                                                                           white,
+                                                                           surfaceScale,
+                                                                           kd,
+                                                                           input,
+                                                                           cr));
             drawClippedBitmap(canvas, paint, 220, y);
 
             y += 110;
 
-            paint.setImageFilter(SkLightingImageFilter::CreatePointLitSpecular(pointLocation,
+            paint.setImageFilter(SkLightingImageFilter::MakePointLitSpecular(pointLocation,
+                                                                             white,
+                                                                             surfaceScale,
+                                                                             ks,
+                                                                             shininess,
+                                                                             input,
+                                                                             cr));
+            drawClippedBitmap(canvas, paint, 0, y);
+
+            paint.setImageFilter(SkLightingImageFilter::MakeDistantLitSpecular(distantDirection,
                                                                                white,
                                                                                surfaceScale,
                                                                                ks,
                                                                                shininess,
                                                                                input,
-                                                                               cr))->unref();
-            drawClippedBitmap(canvas, paint, 0, y);
-
-            paint.setImageFilter(SkLightingImageFilter::CreateDistantLitSpecular(distantDirection,
-                                                                                 white,
-                                                                                 surfaceScale,
-                                                                                 ks,
-                                                                                 shininess,
-                                                                                 input,
-                                                                                 cr))->unref();
+                                                                               cr));
             drawClippedBitmap(canvas, paint, 110, y);
 
-            paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(spotLocation,
-                                                                              spotTarget,
-                                                                              spotExponent,
-                                                                              cutoffAngle,
-                                                                              white,
-                                                                              surfaceScale,
-                                                                              ks,
-                                                                              shininess,
-                                                                              input,
-                                                                              cr))->unref();
+            paint.setImageFilter(SkLightingImageFilter::MakeSpotLitSpecular(spotLocation,
+                                                                            spotTarget,
+                                                                            spotExponent,
+                                                                            cutoffAngle,
+                                                                            white,
+                                                                            surfaceScale,
+                                                                            ks,
+                                                                            shininess,
+                                                                            input,
+                                                                            cr));
             drawClippedBitmap(canvas, paint, 220, y);
 
             y += 110;