Update internal testing ImageFilters to sk_sp

gm/imagefiltersgraph.cpp

 /*
  * Copyright 2012 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 "SkArithmeticMode.h"
@@ skipping 17 matching lines @@
 class SimpleOffsetFilter : public SkImageFilter {
 public:
     class Registrar {
     public:
         Registrar() {
             SkFlattenable::Register("SimpleOffsetFilter",
                                     SimpleOffsetFilter::CreateProc,
                                     SimpleOffsetFilter::GetFlattenableType());
         }
     };
-    static SkImageFilter* Create(SkScalar dx, SkScalar dy, SkImageFilter* input) {
-        return new SimpleOffsetFilter(dx, dy, input);
+    static sk_sp<SkImageFilter> Make(SkScalar dx, SkScalar dy, sk_sp<SkImageFilter> input) {
+        return sk_sp<SkImageFilter>(new SimpleOffsetFilter(dx, dy, std::move(input)));
     }
 
+    SK_TO_STRING_OVERRIDE()
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SimpleOffsetFilter);
+
+protected:
     bool onFilterImageDeprecated(Proxy* proxy, const SkBitmap& src, const Context& ctx,
                                  SkBitmap* dst, SkIPoint* offset) const override {
         SkBitmap source = src;
         SkIPoint srcOffset = SkIPoint::Make(0, 0);
         if (!this->filterInputDeprecated(0, proxy, src, ctx, &source, &srcOffset)) {
             return false;
         }
 
         SkIRect bounds;
         if (!this->applyCropRectDeprecated(ctx, proxy, source, &srcOffset, &bounds, &source)) {
             return false;
         }
 
         SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
         SkCanvas canvas(device);
         SkPaint paint;
         paint.setXfermodeMode(SkXfermode::kSrc_Mode);
         canvas.drawBitmap(source, fDX - bounds.left(), fDY - bounds.top(), &paint);
         *dst = device->accessBitmap(false);
         offset->fX += bounds.left();
         offset->fY += bounds.top();
         return true;
     }
 
-    SK_TO_STRING_OVERRIDE()
-    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SimpleOffsetFilter);
-
-protected:
     void flatten(SkWriteBuffer& buffer) const override {
         this->INHERITED::flatten(buffer);
         buffer.writeScalar(fDX);
         buffer.writeScalar(fDY);
     }
 
 private:
-    SimpleOffsetFilter(SkScalar dx, SkScalar dy, SkImageFilter* input)
-        : SkImageFilter(1, &input), fDX(dx), fDY(dy) {}
+    SimpleOffsetFilter(SkScalar dx, SkScalar dy, sk_sp<SkImageFilter> input)
+        : SkImageFilter(&input, 1, nullptr)
+        , fDX(dx)
+        , fDY(dy) {
+    }
 
     SkScalar fDX, fDY;
 
     typedef SkImageFilter INHERITED;
 };
 
 static SimpleOffsetFilter::Registrar gReg;
 
 sk_sp<SkFlattenable> SimpleOffsetFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkScalar dx = buffer.readScalar();
     SkScalar dy = buffer.readScalar();
-    return sk_sp<SkFlattenable>(Create(dx, dy, common.getInput(0).get()));
+    return Make(dx, dy, common.getInput(0));
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SimpleOffsetFilter::toString(SkString* str) const {
     str->appendf("SimpleOffsetFilter: (");
     str->append(")");
 }
 #endif
 
 class ImageFiltersGraphGM : public skiagm::GM {
@@ skipping 23 matching lines @@
             sk_sp<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur.get()));
             sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Create(cf.get(), erode.get()));
             sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color));
 
             SkPaint paint;
             paint.setImageFilter(std::move(merge));
             canvas->drawPaint(paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
-            SkAutoTUnref<SkImageFilter> morph(SkDilateImageFilter::Create(5, 5));
+            sk_sp<SkImageFilter> morph(SkDilateImageFilter::Create(5, 5));
 
             SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
                                     0, SK_Scalar1, 0, 0, 0,
                                     0, 0, SK_Scalar1, 0, 0,
                                     0, 0, 0, 0.5f, 0 };
 
-            auto matrixFilter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
-            SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter.get(), morph));
+            sk_sp<SkColorFilter> matrixFilter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+            sk_sp<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter.get(),
+                                                                             morph.get()));
             SkPaint paint;
             paint.setImageFilter(SkXfermodeImageFilter::Make(
-                                        SkXfermode::Make(SkXfermode::kSrcOver_Mode), colorMorph));
+                                        SkXfermode::Make(SkXfermode::kSrcOver_Mode),
+                                        colorMorph.get()));
 
             DrawClippedImage(canvas, fImage.get(), paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
             SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
                                     0, SK_Scalar1, 0, 0, 0,
                                     0, 0, SK_Scalar1, 0, 0,
                                     0, 0, 0, 0.5f, 0 };
-            auto matrixCF(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
-            SkAutoTUnref<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Create(matrixCF.get()));
-            SkAutoTUnref<SkImageFilter> offsetFilter(
-                SimpleOffsetFilter::Create(10.0f, 10.f, matrixFilter));
+            sk_sp<SkColorFilter> matrixCF(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
+            sk_sp<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Create(matrixCF.get()));
+            sk_sp<SkImageFilter> offsetFilter(SimpleOffsetFilter::Make(10.0f, 10.f, matrixFilter));
 
             SkPaint paint;
             paint.setImageFilter(
                 SkXfermodeImageFilter::Make(SkArithmeticMode::Make(0, SK_Scalar1, SK_Scalar1, 0),
-                                            matrixFilter, offsetFilter, nullptr));
+                                            matrixFilter.get(), offsetFilter.get(), nullptr));
 
             DrawClippedImage(canvas, fImage.get(), paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
         {
             SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(
               SkIntToScalar(10), SkIntToScalar(10)));
 
             SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
             SkPaint paint;
@@ skipping 63 matching lines @@
     }
 
     sk_sp<SkImage> fImage;
 
     typedef GM INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DEF_GM(return new ImageFiltersGraphGM;)