Update internal testing ImageFilters to sk_sp

tests/ImageFilterTest.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 "SkBitmap.h"
 #include "SkBitmapDevice.h"
 #include "SkBlurImageFilter.h"
@@ skipping 33 matching lines @@
 #include "GrContext.h"
 #include "SkGpuDevice.h"
 #endif
 
 static const int kBitmapSize = 4;
 
 namespace {
 
 class MatrixTestImageFilter : public SkImageFilter {
 public:
-    MatrixTestImageFilter(skiatest::Reporter* reporter, const SkMatrix& expectedMatrix)
-      : SkImageFilter(0, nullptr), fReporter(reporter), fExpectedMatrix(expectedMatrix) {
+    static sk_sp<SkImageFilter> Make(skiatest::Reporter* reporter,
+                                     const SkMatrix& expectedMatrix) {
+        return sk_sp<SkImageFilter>(new MatrixTestImageFilter(reporter, expectedMatrix));
     }
 
+    SK_TO_STRING_OVERRIDE()
+    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
+
+protected:
     bool onFilterImageDeprecated(Proxy*, const SkBitmap& src, const Context& ctx,
                                  SkBitmap* result, SkIPoint* offset) const override {
         REPORTER_ASSERT(fReporter, ctx.ctm() == fExpectedMatrix);
         return true;
     }
 
-    SK_TO_STRING_OVERRIDE()
-    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
-
-protected:
     void flatten(SkWriteBuffer& buffer) const override {
         this->INHERITED::flatten(buffer);
         buffer.writeFunctionPtr(fReporter);
         buffer.writeMatrix(fExpectedMatrix);
     }
 
 private:
+    MatrixTestImageFilter(skiatest::Reporter* reporter, const SkMatrix& expectedMatrix)
+        : INHERITED(nullptr, 0, nullptr)
+        , fReporter(reporter)
+        , fExpectedMatrix(expectedMatrix) {
+    }
+
     skiatest::Reporter* fReporter;
     SkMatrix fExpectedMatrix;
 
     typedef SkImageFilter INHERITED;
 };
 
 void draw_gradient_circle(SkCanvas* canvas, int width, int height) {
     SkScalar x = SkIntToScalar(width / 2);
     SkScalar y = SkIntToScalar(height / 2);
     SkScalar radius = SkMinScalar(x, y) * 0.8f;
@@ skipping 132 matching lines @@
     SkTArray<Filter> fFilters;
 };
 
 }
 
 sk_sp<SkFlattenable> MatrixTestImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     skiatest::Reporter* reporter = (skiatest::Reporter*)buffer.readFunctionPtr();
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
-    return sk_make_sp<MatrixTestImageFilter>(reporter, matrix);
+    return MatrixTestImageFilter::Make(reporter, matrix);
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void MatrixTestImageFilter::toString(SkString* str) const {
     str->appendf("MatrixTestImageFilter: (");
     str->append(")");
 }
 #endif
 
 static sk_sp<SkImage> make_small_image() {
@@ skipping 757 matching lines @@
     SkCanvas canvas(temp);
     canvas.scale(SkIntToScalar(2), SkIntToScalar(2));
 
     SkMatrix expectedMatrix = canvas.getTotalMatrix();
 
     SkRTreeFactory factory;
     SkPictureRecorder recorder;
     SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, &factory, 0);
 
     SkPaint paint;
-    SkAutoTUnref<MatrixTestImageFilter> imageFilter(
-        new MatrixTestImageFilter(reporter, expectedMatrix));
-    paint.setImageFilter(imageFilter.get());
+    paint.setImageFilter(MatrixTestImageFilter::Make(reporter, expectedMatrix));
     recordingCanvas->saveLayer(nullptr, &paint);
     SkPaint solidPaint;
     solidPaint.setColor(0xFFFFFFFF);
     recordingCanvas->save();
     recordingCanvas->scale(SkIntToScalar(10), SkIntToScalar(10));
     recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(100, 100)), solidPaint);
     recordingCanvas->restore(); // scale
     recordingCanvas->restore(); // saveLayer
 
     canvas.drawPicture(recorder.finishRecordingAsPicture());
@@ skipping 574 matching lines @@
 
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_ALL_CONTEXTS(BlurLargeImage_Gpu, reporter, context) {
     auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
                                              SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif