hide SkBlurMaskFilter and SkBlurQuality

SK_SUPPORT_LEGACY_BLURMASKFILTER Bug: skia: Change-Id: Ic3e27e08e6e3cd2ffc1cd13b044e197bebc96236 Reviewed-on: https://skia-review.googlesource.com/113940 Commit-Queue: Mike Reed <reed@google.com> Reviewed-by: Florin Malita <fmalita@chromium.org>
Ragnar-H · Mar 14, 2018 · 1be1f8d · 1be1f8d
1 parent c29c76a
commit 1be1f8d
Show file tree

Hide file tree

Showing 68 changed files with 245 additions and 318 deletions.
diff --git a/bench/BlurBench.cpp b/bench/BlurBench.cpp
@@ -6,8 +6,8 @@
  */
 #include "Benchmark.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkShader.h"
@@ -31,17 +31,14 @@ static const char* gStyleName[] = {
 class BlurBench : public Benchmark {
     SkScalar    fRadius;
     SkBlurStyle fStyle;
-    uint32_t    fFlags;
     SkString    fName;
 
 public:
-    BlurBench(SkScalar rad, SkBlurStyle bs, uint32_t flags = 0) {
+    BlurBench(SkScalar rad, SkBlurStyle bs) {
         fRadius = rad;
         fStyle = bs;
-        fFlags = flags;
         const char* name = rad > 0 ? gStyleName[bs] : "none";
-        const char* quality = flags & SkBlurMaskFilter::kHighQuality_BlurFlag ? "high_quality"
-                                                                              : "low_quality";
+        const char* quality = "high_quality";
         if (SkScalarFraction(rad) != 0) {
             fName.printf("blur_%.2f_%s_%s", SkScalarToFloat(rad), name, quality);
         } else {
@@ -67,9 +64,8 @@ class BlurBench : public Benchmark {
             r.offset(fRadius, fRadius);
 
             if (fRadius > 0) {
-                paint.setMaskFilter(SkBlurMaskFilter::Make(fStyle,
-                                                          SkBlurMask::ConvertRadiusToSigma(fRadius),
-                                                          fFlags));
+                paint.setMaskFilter(SkMaskFilter::MakeBlur(fStyle,
+                                                      SkBlurMask::ConvertRadiusToSigma(fRadius)));
             }
             canvas->drawOval(r, paint);
         }
@@ -104,15 +100,4 @@ DEF_BENCH(return new BlurBench(REAL, kSolid_SkBlurStyle);)
 DEF_BENCH(return new BlurBench(REAL, kOuter_SkBlurStyle);)
 DEF_BENCH(return new BlurBench(REAL, kInner_SkBlurStyle);)
 
-DEF_BENCH(return new BlurBench(MINI, kNormal_SkBlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
-
-DEF_BENCH(return new BlurBench(SMALL, kNormal_SkBlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
-
-DEF_BENCH(return new BlurBench(BIG, kNormal_SkBlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
-
-DEF_BENCH(return new BlurBench(REALBIG, kNormal_SkBlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
-
-DEF_BENCH(return new BlurBench(REAL, kNormal_SkBlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
-DEF_BENCH(return new BlurBench(CUTOVER, kNormal_SkBlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
-
 DEF_BENCH(return new BlurBench(0, kNormal_SkBlurStyle);)
diff --git a/bench/BlurOccludedRRectBench.cpp b/bench/BlurOccludedRRectBench.cpp
@@ -6,8 +6,8 @@
  */
 
 #include "Benchmark.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkRRect.h"
 #include "SkRect.h"
@@ -48,7 +48,7 @@ class BlurOccludedRRectBench : public Benchmark {
                         SkPaint firstBlur;
                         firstBlur.setAntiAlias(true);
                         firstBlur.setColor(0x09000000);
-                        firstBlur.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
+                        firstBlur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                                                        2.5f,
                                                                        occRect));
 
@@ -60,7 +60,7 @@ class BlurOccludedRRectBench : public Benchmark {
                             SkPaint secondBlur;
                             secondBlur.setAntiAlias(true);
                             secondBlur.setColor(0x30000000);
-                            secondBlur.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
+                            secondBlur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                                                             6.0f,
                                                                             occRect));
 

diff --git a/bench/BlurRectBench.cpp b/bench/BlurRectBench.cpp
@@ -145,7 +145,7 @@ class BlurRectBoxFilterBench: public BlurRectSeparableBench {
     void makeBlurryRect(const SkRect&) override {
         SkMask mask;
         if (!SkBlurMask::BoxBlur(&mask, fSrcMask, SkBlurMask::ConvertRadiusToSigma(this->radius()),
-                                 kNormal_SkBlurStyle, kHigh_SkBlurQuality)) {
+                                 kNormal_SkBlurStyle)) {
             return;
         }
         SkMask::FreeImage(mask.fImage);

diff --git a/bench/BlurRectsBench.cpp b/bench/BlurRectsBench.cpp
@@ -6,8 +6,8 @@
 */
 
 #include "Benchmark.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkRect.h"
@@ -31,7 +31,7 @@ class BlurRectsBench : public Benchmark {
 
     void onDraw(int loops, SkCanvas* canvas) override {
         SkPaint paint;
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, fRadius));
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, fRadius));
 
         SkPath path;
         path.addRect(fOuter, SkPath::kCW_Direction);

diff --git a/bench/BlurRoundRectBench.cpp b/bench/BlurRoundRectBench.cpp
@@ -7,10 +7,10 @@
 
 #include "Benchmark.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkLayerDrawLooper.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPoint.h"
@@ -48,9 +48,8 @@ class BlurRoundRectBench : public Benchmark {
             info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
             info.fPostTranslate = false;
             SkPaint* paint = looperBuilder.addLayerOnTop(info);
-            paint->setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                                        SkBlurMask::ConvertRadiusToSigma(0.5),
-                                                        SkBlurMaskFilter::kHighQuality_BlurFlag));
+            paint->setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
+                                                        SkBlurMask::ConvertRadiusToSigma(0.5)));
             paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorLTGRAY,
                                                                 SkBlendMode::kSrcIn));
             paint->setColor(SK_ColorGRAY);

diff --git a/bench/RectoriBench.cpp b/bench/RectoriBench.cpp
@@ -6,9 +6,9 @@
  */
 
 #include "Benchmark.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkLayerDrawLooper.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkRandom.h"
@@ -86,8 +86,7 @@ class RectoriBench : public Benchmark {
 
         SkPaint* paint = looperBuilder.addLayer(info);
 
-        paint->setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma,
-                                                    SkBlurMaskFilter::kHighQuality_BlurFlag));
+        paint->setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma));
 
         //-----------------------------------------------
         info.fPaintBits = 0;

diff --git a/fuzz/FuzzCanvas.cpp b/fuzz/FuzzCanvas.cpp
@@ -509,8 +509,9 @@ static sk_sp<SkMaskFilter> make_fuzz_maskfilter(Fuzz* fuzz) {
                 fuzz->next(&occluder);
             }
             uint32_t flags;
-            fuzz->nextRange(&flags, 0, 3);
-            return SkBlurMaskFilter::Make(blurStyle, sigma, occluder, flags);
+            fuzz->nextRange(&flags, 0, 1);
+            bool respectCTM = flags != 0;
+            return SkMaskFilter::MakeBlur(blurStyle, sigma, occluder, respectCTM);
         }
         case 2: {
             SkRRect first, second;

diff --git a/gm/alpha_image.cpp b/gm/alpha_image.cpp
@@ -7,9 +7,9 @@
 
 #include "gm.h"
 
-#include "SkBlurMaskFilter.h"
 #include "SkColorFilter.h"
 #include "SkImage.h"
+#include "SkMaskFilter.h"
 #include "SkShader.h"
 
 static SkBitmap make_alpha_image(int w, int h) {
@@ -39,7 +39,7 @@ DEF_SIMPLE_GM(alpha_image, canvas, 256, 256) {
     SkPaint paint;
 
     paint.setColorFilter(make_color_filter());
-    paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 10.0f, 0));
+    paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 10.0f));
     canvas->drawImage(image.get(), 16, 16, &paint);
 
     paint.setColorFilter(nullptr);

diff --git a/gm/bigblurs.cpp b/gm/bigblurs.cpp
@@ -8,7 +8,7 @@
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
+#include "SkMaskFilter.h"
 #include "SkPath.h"
 
 namespace skiagm {
@@ -71,7 +71,7 @@ class BigBlursGM : public GM {
 
         for (int i = 0; i < 2; ++i) {
             for (int j = 0; j <= kLastEnum_SkBlurStyle; ++j) {
-                blurPaint.setMaskFilter(SkBlurMaskFilter::Make((SkBlurStyle)j, kSigma));
+                blurPaint.setMaskFilter(SkMaskFilter::MakeBlur((SkBlurStyle)j, kSigma));
 
                 for (int k = 0; k < (int)SK_ARRAY_COUNT(origins); ++k) {
                     canvas->save();

diff --git a/gm/bleed.cpp b/gm/bleed.cpp
@@ -7,10 +7,10 @@
 
 #include "gm.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
+#include "SkMaskFilter.h"
 #include "SkTDArray.h"
 #include "SkUtils.h"
 #include "sk_tool_utils.h"
@@ -281,7 +281,7 @@ class BleedGM : public skiagm::GM {
 
         SkPaint paint;
         paint.setFilterQuality(filter);
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                                    SkBlurMask::ConvertRadiusToSigma(3)));
         paint.setShader(fShader);
         paint.setColor(SK_ColorBLUE);
@@ -299,7 +299,7 @@ class BleedGM : public skiagm::GM {
 
         SkPaint paint;
         paint.setFilterQuality(filter);
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kOuter_SkBlurStyle,
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle,
                                                    SkBlurMask::ConvertRadiusToSigma(7)));
         paint.setShader(fShader);
         paint.setColor(SK_ColorBLUE);

diff --git a/gm/blurcircles.cpp b/gm/blurcircles.cpp
@@ -7,8 +7,8 @@
 
 #include "gm.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkString.h"
 
@@ -31,10 +31,9 @@ class BlurCirclesGM : public skiagm::GM {
         const float blurRadii[kNumBlurs] = { 1,5,10,20 };
 
         for (int i = 0; i < kNumBlurs; ++i) {
-            fBlurFilters[i] = SkBlurMaskFilter::Make(
+            fBlurFilters[i] = SkMaskFilter::MakeBlur(
                                     kNormal_SkBlurStyle,
-                                    SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(blurRadii[i])),
-                                    SkBlurMaskFilter::kHighQuality_BlurFlag);
+                                    SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(blurRadii[i])));
         }
     }
 

diff --git a/gm/blurcircles2.cpp b/gm/blurcircles2.cpp
@@ -55,9 +55,8 @@ class BlurCircles2GM : public skiagm::GM {
         };
 
         auto blurMaker = [] (SkScalar radius) ->sk_sp<SkMaskFilter> {
-            return SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                          SkBlurMask::ConvertRadiusToSigma(radius),
-                                          SkBlurMaskFilter::kHighQuality_BlurFlag);
+            return SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
+                                          SkBlurMask::ConvertRadiusToSigma(radius));
         };
 
         SkPaint paint;

diff --git a/gm/blurignorexform.cpp b/gm/blurignorexform.cpp
@@ -9,8 +9,8 @@
 #include "sk_tool_utils.h"
 
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 
 // This GM tests out the SkBlurMaskFilter's kIgnoreTransform flag. That flag causes the blur mask
@@ -42,10 +42,10 @@ class BlurIgnoreXformGM : public skiagm::GM {
 
     void onOnceBeforeDraw() override {
         for (int i = 0; i < kNumBlurs; ++i) {
-            fBlurFilters[i] = SkBlurMaskFilter::Make(
+            fBlurFilters[i] = SkMaskFilter::MakeBlur(
                                     kNormal_SkBlurStyle,
                                     SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(20)),
-                                    SkBlurMaskFilter::kHighQuality_BlurFlag | kBlurFlags[i].fFlags);
+                                    kBlurFlags[i].fRespectCTM);
         }
     }
 
@@ -114,7 +114,7 @@ class BlurIgnoreXformGM : public skiagm::GM {
     static constexpr int kNumBlurs = 2;
 
     static const struct BlurFlags {
-        uint32_t fFlags;
+        bool fRespectCTM;
         const char* fName;
     } kBlurFlags[kNumBlurs];
 
@@ -130,8 +130,8 @@ class BlurIgnoreXformGM : public skiagm::GM {
 };
 
 const BlurIgnoreXformGM::BlurFlags BlurIgnoreXformGM::kBlurFlags[] = {
-    {0, "none"},
-    {SkBlurMaskFilter::kIgnoreTransform_BlurFlag, "IgnoreTransform"}
+    {true, "none"},
+    {false, "IgnoreTransform"}
 };
 
 const BlurIgnoreXformGM::MatrixScale BlurIgnoreXformGM::kMatrixScales[] = {

diff --git a/gm/blurimagevmask.cpp b/gm/blurimagevmask.cpp
@@ -5,8 +5,8 @@
  * found in the LICENSE file.
  */
 
-#include "SkBlurMaskFilter.h"
 #include "SkBlurImageFilter.h"
+#include "SkMaskFilter.h"
 #include "gm.h"
 #include "sk_tool_utils.h"
 
@@ -38,9 +38,7 @@ DEF_SIMPLE_GM(blurimagevmask, canvas, 700, 1200) {
 
         r.offset(250, 0);
 
-        paint.setMaskFilter(
-            SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma,
-                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma));
         canvas->drawRect(r, paint);
         paint.setMaskFilter(nullptr);
 
@@ -61,7 +59,7 @@ DEF_SIMPLE_GM(blur_image, canvas, 500, 500) {
     auto image = GetResourceAsImage("images/mandrill_128.png");
 
     SkPaint paint;
-    paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 4));
+    paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 4));
 
     // both of these should draw with the blur, but (formerally) we had a bug where the unscaled
     // version (taking the spriteblitter code path) ignore the maskfilter.

diff --git a/gm/blurquickreject.cpp b/gm/blurquickreject.cpp
@@ -7,8 +7,8 @@
 
 #include "gm.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 
 // This GM tests out the quick reject bounds of the blur mask filter. It draws
 // four blurred rects around a central clip. The blurred rect geometry outset
@@ -56,7 +56,7 @@ class BlurQuickRejectGM : public skiagm::GM {
 
         SkPaint blurPaint;
         blurPaint.setFilterQuality(kLow_SkFilterQuality);
-        blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
+        blurPaint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                                     SkBlurMask::ConvertRadiusToSigma(kBlurRadius)));
 
         canvas->clear(SK_ColorBLACK);

diff --git a/gm/blurrect.cpp b/gm/blurrect.cpp
@@ -7,8 +7,8 @@
 
 #include "gm.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPath.h"
 
 #define STROKE_WIDTH    SkIntToScalar(10)
@@ -95,9 +95,8 @@ class BlurRectGM : public skiagm::GM {
 protected:
     void onOnceBeforeDraw() override {
         for (int i = 0; i <= kLastEnum_SkBlurStyle; ++i) {
-            fMaskFilters[i] = SkBlurMaskFilter::Make((SkBlurStyle)i,
-                                  SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(STROKE_WIDTH/2)),
-                                  SkBlurMaskFilter::kHighQuality_BlurFlag);
+            fMaskFilters[i] = SkMaskFilter::MakeBlur((SkBlurStyle)i,
+                                  SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(STROKE_WIDTH/2)));
         }
     }