switch maskfilters to sk_sp

tests/BlurTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkBlurDrawLooper.h"
@@ skipping 93 matching lines @@
     paint.setColor(SK_ColorGRAY);
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(SkIntToScalar(strokeWidth));
 
     SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5));
     for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) {
         SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style);
 
         const uint32_t flagPermutations = SkBlurMaskFilter::kAll_BlurFlag;
         for (uint32_t flags = 0; flags < flagPermutations; ++flags) {
-            SkMaskFilter* filter;
-            filter = SkBlurMaskFilter::Create(blurStyle, sigma, flags);
-
-            paint.setMaskFilter(filter);
-            filter->unref();
+            paint.setMaskFilter(SkBlurMaskFilter::Make(blurStyle, sigma, flags));
 
             for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
                 SkPath path;
                 tests[test].addPath(&path);
                 SkPath strokedPath;
                 paint.getFillPath(path, &strokedPath);
                 SkRect refBound = strokedPath.getBounds();
                 SkIRect iref;
                 refBound.roundOut(&iref);
                 iref.inset(-outset, -outset);
@@ skipping 98 matching lines @@
 static void blur_path(SkCanvas* canvas, const SkPath& path,
                       SkScalar gaussianSigma) {
 
     SkScalar midX = path.getBounds().centerX();
     SkScalar midY = path.getBounds().centerY();
 
     canvas->translate(-midX, -midY);
 
     SkPaint blurPaint;
     blurPaint.setColor(SK_ColorWHITE);
-    SkMaskFilter* filter = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
-                                                    gaussianSigma,
-                                                    SkBlurMaskFilter::kHighQuality_BlurFlag);
-    blurPaint.setMaskFilter(filter)->unref();
+    blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, gaussianSigma,
+                                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
 
     canvas->drawColor(SK_ColorBLACK);
     canvas->drawPath(path, blurPaint);
 }
 
 // Readback the blurred draw results from the canvas
 static void readback(SkCanvas* canvas, int* result, int resultCount) {
     SkBitmap readback;
     readback.allocN32Pixels(resultCount, 30);
 
@@ skipping 205 matching lines @@
 }
 
 static void make_noop_layer(SkLayerDrawLooper::Builder* builder) {
     SkLayerDrawLooper::LayerInfo info;
 
     info.fPaintBits = 0;
     info.fColorMode = SkXfermode::kDst_Mode;
     builder->addLayer(info);
 }
 
-static void make_blur_layer(SkLayerDrawLooper::Builder* builder, SkMaskFilter* mf) {
+static void make_blur_layer(SkLayerDrawLooper::Builder* builder, sk_sp<SkMaskFilter> mf) {
     SkLayerDrawLooper::LayerInfo info;
 
     info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit;
     info.fColorMode = SkXfermode::kSrc_Mode;
     SkPaint* paint = builder->addLayer(info);
-    paint->setMaskFilter(mf);
+    paint->setMaskFilter(std::move(mf));
 }
 
-static void test_layerDrawLooper(skiatest::Reporter* reporter, SkMaskFilter* mf, SkScalar sigma,
-                                 SkBlurStyle style, SkBlurQuality quality, bool expectSuccess) {
+static void test_layerDrawLooper(skiatest::Reporter* reporter, sk_sp<SkMaskFilter> mf,
+                                 SkScalar sigma, SkBlurStyle style, SkBlurQuality quality,
+                                 bool expectSuccess) {
 
     SkLayerDrawLooper::LayerInfo info;
     SkLayerDrawLooper::Builder builder;
 
     // 1 layer is too few
     make_noop_layer(&builder);
     test_looper(reporter, builder.detach(), sigma, style, quality, false);
 
     // 2 layers is good, but need blur
     make_noop_layer(&builder);
@@ skipping 23 matching lines @@
 
     // Test asABlur for SkBlurMaskFilter
     //
     for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) {
         const SkBlurStyle style = (SkBlurStyle)styles[i];
         for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
             const SkScalar sigma = sigmas[j];
             for (int flags = 0; flags <= SkBlurMaskFilter::kAll_BlurFlag; ++flags) {
                 const SkBlurQuality quality = blurMaskFilterFlags_as_quality(flags);
 
-                SkAutoTUnref<SkMaskFilter> mf(SkBlurMaskFilter::Create(style, sigma, flags));
+                sk_sp<SkMaskFilter> mf(SkBlurMaskFilter::Make(style, sigma, flags));
                 if (nullptr == mf.get()) {
                     REPORTER_ASSERT(reporter, sigma <= 0);
                 } else {
                     REPORTER_ASSERT(reporter, sigma > 0);
                     SkMaskFilter::BlurRec rec;
                     bool success = mf->asABlur(&rec);
                     if (flags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) {
                         REPORTER_ASSERT(reporter, !success);
                     } else {
                         REPORTER_ASSERT(reporter, success);
                         REPORTER_ASSERT(reporter, rec.fSigma == sigma);
                         REPORTER_ASSERT(reporter, rec.fStyle == style);
                         REPORTER_ASSERT(reporter, rec.fQuality == quality);
                     }
-                    test_layerDrawLooper(reporter, mf, sigma, style, quality, success);
+                    test_layerDrawLooper(reporter, std::move(mf), sigma, style, quality, success);
                 }
                 test_blurDrawLooper(reporter, sigma, style, flags);
             }
         }
     }
 
     // Test asABlur for SkEmbossMaskFilter -- should never succeed
     //
     {
         SkEmbossMaskFilter::Light light = {
             { 1, 1, 1 }, 0, 127, 127
         };
         for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
             const SkScalar sigma = sigmas[j];
-            SkAutoTUnref<SkMaskFilter> mf(SkEmbossMaskFilter::Create(sigma, light));
-            if (mf.get()) {
+            auto mf(SkEmbossMaskFilter::Make(sigma, light));
+            if (mf) {
                 SkMaskFilter::BlurRec rec;
                 bool success = mf->asABlur(&rec);
                 REPORTER_ASSERT(reporter, !success);
             }
         }
     }
 }
 
 #if SK_SUPPORT_GPU
 
 // This exercises the problem discovered in crbug.com/570232. The return value from
 // SkBlurMask::BoxBlur wasn't being checked in SkBlurMaskFilter.cpp::GrRRectBlurEffect::Create
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SmallBoxBlurBug, reporter, ctx) {
 
     SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
     auto surface(SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info));
     SkCanvas* canvas = surface->getCanvas();
 
     SkRect r = SkRect::MakeXYWH(10, 10, 100, 100);
     SkRRect rr = SkRRect::MakeRectXY(r, 10, 10);
 
     SkPaint p;
-    p.setMaskFilter(SkBlurMaskFilter::Create(kNormal_SkBlurStyle, 0.01f))->unref();
+    p.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.01f));
 
     canvas->drawRRect(rr, p);
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////