Update MatrixConvolutionImageFilter to sk_sp

fuzz/FilterFuzz.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 "Fuzz.h"
 #include "Sk1DPathEffect.h"
 #include "Sk2DPathEffect.h"
 #include "SkAlphaThresholdFilter.h"
@@ skipping 534 matching lines @@
     enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
            DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
            DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
            MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS };
 
     switch (R(NUM_FILTERS)) {
     case ALPHA_THRESHOLD:
         filter = SkAlphaThresholdFilter::Make(make_region(),
                                               make_scalar(),
                                               make_scalar(),
-                                              nullptr);
+                                              make_image_filter());
         break;
     case MERGE:
         filter = SkMergeImageFilter::Make(make_image_filter(),
                                           make_image_filter(),
                                           make_xfermode());
         break;
     case COLOR: {
         sk_sp<SkColorFilter> cf(make_color_filter());
         filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter())
                     : nullptr;
@@ skipping 38 matching lines @@
         SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
                                                      SkIntToScalar(kBitmapSize)));
         SkISize size = SkISize::Make(R(10)+1, R(10)+1);
         int arraySize = size.width() * size.height();
         SkTArray<SkScalar> kernel(arraySize);
         for (int i = 0; i < arraySize; ++i) {
             kernel.push_back() = make_scalar();
         }
         SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())),
                                                R(SkIntToScalar(size.height())));
-        sk_sp<SkImageFilter> subFilter(make_image_filter());
 
-        filter = sk_sp<SkImageFilter>(SkMatrixConvolutionImageFilter::Create(
-                                                        size,
-                                                        kernel.begin(),
-                                                        make_scalar(),
-                                                        make_scalar(),
-                                                        kernelOffset,
-                                                        (SkMatrixConvolutionImageFilter::TileMode)R(3),
-                                                        R(2) == 1,
-                                                        subFilter.get(),
-                                                        &cropR));
+        filter = SkMatrixConvolutionImageFilter::Make(size,
+                                                      kernel.begin(),
+                                                      make_scalar(),
+                                                      make_scalar(),
+                                                      kernelOffset,
+                                                      (SkMatrixConvolutionImageFilter::TileMode)R(3),
+                                                      R(2) == 1,
+                                                      make_image_filter(),
+                                                      &cropR);
         break;
     }
     case COMPOSE:
         filter = SkComposeImageFilter::Make(make_image_filter(), make_image_filter());
         break;
     case DISTANT_LIGHT: {
         sk_sp<SkImageFilter> subFilter(make_image_filter());
 
         filter = (R(2) == 1)
                  ? sk_sp<SkImageFilter>(SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
@@ skipping 162 matching lines @@
 DEF_FUZZ(SerializedImageFilter, f) {
     fuzz = f;
     SkImageFilter* filter = make_serialized_image_filter();
 
     SkPaint paint;
     SkSafeUnref(paint.setImageFilter(filter));
     SkBitmap bitmap;
     SkCanvas canvas(bitmap);
     drawClippedBitmap(&canvas, 0, 0, paint);
 }