Update SkMatrixImageFilter 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 207 matching lines @@
         this->addFilter("offset",
                         SkOffsetImageFilter::Make(SK_Scalar1, SK_Scalar1, input,
                                                   cropRect).release());
         this->addFilter("dilate", SkDilateImageFilter::Make(3, 2, input, cropRect).release());
         this->addFilter("erode", SkErodeImageFilter::Make(2, 3, input, cropRect).release());
         this->addFilter("tile", SkTileImageFilter::Create(
             SkRect::MakeXYWH(0, 0, 50, 50),
             cropRect ? cropRect->rect() : SkRect::MakeXYWH(0, 0, 100, 100),
             input.get()));
         if (!cropRect) {
-            this->addFilter("matrix", SkImageFilter::CreateMatrixFilter(
-                matrix, kLow_SkFilterQuality, input.get()));
+            this->addFilter("matrix",
+                SkImageFilter::MakeMatrixFilter(matrix, kLow_SkFilterQuality, input).release());
         }
 
         {
             sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(five, five, input));
 
             this->addFilter("blur and offset", SkOffsetImageFilter::Make(five, five,
                                                                          std::move(blur),
                                                                          cropRect).release());
         }
         {
@@ skipping 554 matching lines @@
 }
 
 static void draw_saveLayer_picture(int width, int height, int tileSize,
                                    SkBBHFactory* factory, SkBitmap* result) {
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(50), 0);
 
     sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode));
     sk_sp<SkImageFilter> cfif(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
-    sk_sp<SkImageFilter> imageFilter(SkImageFilter::CreateMatrixFilter(matrix, 
-                                                                       kNone_SkFilterQuality,
-                                                                       cfif.get()));
+    sk_sp<SkImageFilter> imageFilter(SkImageFilter::MakeMatrixFilter(matrix,
+                                                                     kNone_SkFilterQuality,
+                                                                     std::move(cfif)));
 
     SkPaint paint;
     paint.setImageFilter(std::move(imageFilter));
     SkPictureRecorder recorder;
     SkRect bounds = SkRect::Make(SkIRect::MakeXYWH(0, 0, 50, 50));
     SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(width),
                                                         SkIntToScalar(height),
                                                         factory, 0);
     recordingCanvas->translate(-55, 0);
     recordingCanvas->saveLayer(&bounds, &paint);
@@ skipping 573 matching lines @@
     SkCanvas canvas(temp);
     canvas.clear(0x0);
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(10, 10);
     bitmap.eraseColor(SK_ColorGREEN);
 
     SkMatrix matrix;
     matrix.setScale(SkIntToScalar(2), SkIntToScalar(2));
     matrix.postTranslate(SkIntToScalar(-20), SkIntToScalar(-20));
-    SkAutoTUnref<SkImageFilter> matrixFilter(
-        SkImageFilter::CreateMatrixFilter(matrix, kLow_SkFilterQuality));
+    sk_sp<SkImageFilter> matrixFilter(
+        SkImageFilter::MakeMatrixFilter(matrix, kLow_SkFilterQuality, nullptr));
 
     // Test that saveLayer() with a filter nested inside another saveLayer() applies the
     // correct offset to the filter matrix.
     SkRect bounds1 = SkRect::MakeXYWH(10, 10, 30, 30);
     canvas.saveLayer(&bounds1, nullptr);
     SkPaint filterPaint;
-    filterPaint.setImageFilter(matrixFilter);
+    filterPaint.setImageFilter(std::move(matrixFilter));
     SkRect bounds2 = SkRect::MakeXYWH(20, 20, 10, 10);
     canvas.saveLayer(&bounds2, &filterPaint);
     SkPaint greenPaint;
     greenPaint.setColor(SK_ColorGREEN);
     canvas.drawRect(bounds2, greenPaint);
     canvas.restore();
     canvas.restore();
     SkPaint strokePaint;
     strokePaint.setStyle(SkPaint::kStroke_Style);
     strokePaint.setColor(SK_ColorRED);
@@ skipping 285 matching lines @@
 
     test_xfermode_cropped_input(&canvas, reporter);
 }
 
 DEF_GPUTEST_FOR_ALL_CONTEXTS(BlurLargeImage_Gpu, reporter, ctxInfo) {
     auto surface(SkSurface::MakeRenderTarget(ctxInfo.fGrContext, SkBudgeted::kYes,
                                              SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
 #endif