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>

30 files changed, 104 insertions, 128 deletions

diff --git a/gm/alpha_image.cpp b/gm/alpha_image.cpp
index 0a0da03a3b..06fb3f6549 100644
--- 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
index be5a6b8f9f..83f6bd4a44 100644
--- 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 @@ protected:
 
         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
index b6ee10b555..85d3328428 100644
--- 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 @@ protected:
 
         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 @@ protected:
 
         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
index 13cbeb864d..e0978c0caf 100644
--- 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 @@ protected:
         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
index a65763e540..c2739a948c 100644
--- a/gm/blurcircles2.cpp
+++ b/gm/blurcircles2.cpp
@@ -55,9 +55,8 @@ protected:
         };
 
         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
index 8db56ab8d7..1e89dec681 100644
--- 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 @@ protected:
 
     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 @@ private:
     static constexpr int kNumBlurs = 2;
 
     static const struct BlurFlags {
-        uint32_t fFlags;
+        bool fRespectCTM;
         const char* fName;
     } kBlurFlags[kNumBlurs];
 
@@ -130,8 +130,8 @@ private:
 };
 
 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
index c1f9b3e1ec..22e49c5f00 100644
--- 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
index 452cdf7e91..237c678f4d 100644
--- 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 @@ protected:
 
         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
index 54f3c216c0..a718cdeac6 100644
--- 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 @@ public:
 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)));
         }
     }
 
diff --git a/gm/blurredclippedcircle.cpp b/gm/blurredclippedcircle.cpp
index f62cb1270e..533555d015 100644
--- a/gm/blurredclippedcircle.cpp
+++ b/gm/blurredclippedcircle.cpp
@@ -7,9 +7,9 @@
 
 #include "gm.h"
 #include "sk_tool_utils.h"
-#include "SkBlurMaskFilter.h"
 #include "SkClipOpPriv.h"
 #include "SkColorFilter.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkRRect.h"
 
@@ -65,10 +65,9 @@ protected:
 
                     SkPaint paint;
 
-                    paint.setMaskFilter(SkBlurMaskFilter::Make(
+                    paint.setMaskFilter(SkMaskFilter::MakeBlur(
                                             kNormal_SkBlurStyle,
-                                            1.366025f,
-                                            SkBlurMaskFilter::kHighQuality_BlurFlag));
+                                            1.366025f));
                     paint.setColorFilter(SkColorFilter::MakeModeFilter(
                                              SK_ColorRED,
                                              SkBlendMode::kSrcIn));
diff --git a/gm/blurroundrect.cpp b/gm/blurroundrect.cpp
index 32a5bc4e49..289e156345 100644
--- a/gm/blurroundrect.cpp
+++ b/gm/blurroundrect.cpp
@@ -8,10 +8,10 @@
 #include "gm.h"
 #include "sk_tool_utils.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"
@@ -55,10 +55,9 @@ public:
             info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
             info.fPostTranslate = false;
             SkPaint* paint = looperBuilder.addLayerOnTop(info);
-            paint->setMaskFilter(SkBlurMaskFilter::Make(
+            paint->setMaskFilter(SkMaskFilter::MakeBlur(
                     kNormal_SkBlurStyle,
-                    SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf),
-                    SkBlurMaskFilter::kHighQuality_BlurFlag));
+                    SkBlurMask::ConvertRadiusToSigma(SK_ScalarHalf)));
             paint->setColorFilter(SkColorFilter::MakeModeFilter(
                     sk_tool_utils::color_to_565(SK_ColorLTGRAY),
                     SkBlendMode::kSrcIn));
@@ -143,9 +142,8 @@ protected:
                 for (int k = 0; k <= 1; k++) {
                     SkPaint paint;
                     paint.setColor(SK_ColorBLACK);
-                    paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                   SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(blurRadii[i])),
-                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
+                    paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
+                                   SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(blurRadii[i]))));
 
                     bool useRadial = SkToBool(k);
                     if (useRadial) {
diff --git a/gm/blurs.cpp b/gm/blurs.cpp
index 0e0374e0a5..1ba13691e2 100644
--- a/gm/blurs.cpp
+++ b/gm/blurs.cpp
@@ -9,8 +9,8 @@
 #include "sk_tool_utils.h"
 #include "Resources.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkImage.h"
+#include "SkMaskFilter.h"
 #include "SkPath.h"
 
 DEF_SIMPLE_GM_BG(blurs, canvas, 700, 500, sk_tool_utils::color_to_565(0xFFDDDDDD)) {
@@ -32,43 +32,34 @@ DEF_SIMPLE_GM_BG(blurs, canvas, 700, 500, sk_tool_utils::color_to_565(0xFFDDDDDD
         paint.setTextSize(SkIntToScalar(25));
         canvas->translate(SkIntToScalar(-40), SkIntToScalar(0));
 
-        SkBlurMaskFilter::BlurFlags flags = SkBlurMaskFilter::kNone_BlurFlag;
-        for (int j = 0; j < 2; j++) {
-            canvas->save();
-            paint.setColor(SK_ColorBLUE);
-            for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
-                if (gRecs[i].fStyle != NONE) {
-                    paint.setMaskFilter(SkBlurMaskFilter::Make(gRecs[i].fStyle,
-                                           SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(20)),
-                                           flags));
-                } else {
-                    paint.setMaskFilter(nullptr);
-                }
-                canvas->drawCircle(SkIntToScalar(200 + gRecs[i].fCx*100),
-                                   SkIntToScalar(200 + gRecs[i].fCy*100),
-                                   SkIntToScalar(50),
-                                   paint);
-            }
-            // draw text
-            {
-                paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                           SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4)),
-                                           flags));
-                SkScalar x = SkIntToScalar(70);
-                SkScalar y = SkIntToScalar(400);
-                paint.setColor(SK_ColorBLACK);
-                canvas->drawString("Hamburgefons Style", x, y, paint);
-                canvas->drawString("Hamburgefons Style",
-                                 x, y + SkIntToScalar(50), paint);
+        paint.setColor(SK_ColorBLUE);
+        for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
+            if (gRecs[i].fStyle != NONE) {
+                paint.setMaskFilter(SkMaskFilter::MakeBlur(gRecs[i].fStyle,
+                                       SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(20))));
+            } else {
                 paint.setMaskFilter(nullptr);
-                paint.setColor(SK_ColorWHITE);
-                x -= SkIntToScalar(2);
-                y -= SkIntToScalar(2);
-                canvas->drawString("Hamburgefons Style", x, y, paint);
             }
-            canvas->restore();
-            flags = SkBlurMaskFilter::kHighQuality_BlurFlag;
-            canvas->translate(SkIntToScalar(350), SkIntToScalar(0));
+            canvas->drawCircle(SkIntToScalar(200 + gRecs[i].fCx*100),
+                               SkIntToScalar(200 + gRecs[i].fCy*100),
+                               SkIntToScalar(50),
+                               paint);
+        }
+        // draw text
+        {
+            paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
+                                       SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(4))));
+            SkScalar x = SkIntToScalar(70);
+            SkScalar y = SkIntToScalar(400);
+            paint.setColor(SK_ColorBLACK);
+            canvas->drawString("Hamburgefons Style", x, y, paint);
+            canvas->drawString("Hamburgefons Style",
+                             x, y + SkIntToScalar(50), paint);
+            paint.setMaskFilter(nullptr);
+            paint.setColor(SK_ColorWHITE);
+            x -= SkIntToScalar(2);
+            y -= SkIntToScalar(2);
+            canvas->drawString("Hamburgefons Style", x, y, paint);
         }
 }
 
@@ -83,7 +74,7 @@ DEF_SIMPLE_GM_BG(blurs, canvas, 700, 500, sk_tool_utils::color_to_565(0xFFDDDDDD
 DEF_SIMPLE_GM(blur2rects, canvas, 700, 500) {
         SkPaint paint;
 
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 2.3f));
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 2.3f));
 
         SkRect outer = SkRect::MakeXYWH(10.125f, 10.125f, 100.125f, 100);
         SkRect inner = SkRect::MakeXYWH(20.25f, 20.125f, 80, 80);
@@ -101,7 +92,7 @@ DEF_SIMPLE_GM(blur2rects, canvas, 700, 500) {
 
 DEF_SIMPLE_GM(blur2rectsnonninepatch, canvas, 700, 500) {
         SkPaint paint;
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 4.3f));
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 4.3f));
 
         SkRect outer = SkRect::MakeXYWH(10, 110, 100, 100);
         SkRect inner = SkRect::MakeXYWH(50, 150, 10, 10);
@@ -122,7 +113,7 @@ DEF_SIMPLE_GM(blur2rectsnonninepatch, canvas, 700, 500) {
 
 DEF_SIMPLE_GM(BlurDrawImage, canvas, 256, 256) {
     SkPaint paint;
-    paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 10, 0));
+    paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 10));
     canvas->clear(0xFF88FF88);
     if (auto image = GetResourceAsImage("images/mandrill_512_q075.jpg")) {
         canvas->scale(0.25, 0.25);
diff --git a/gm/blurtextsmallradii.cpp b/gm/blurtextsmallradii.cpp
index 610338144c..62572ce49d 100644
--- a/gm/blurtextsmallradii.cpp
+++ b/gm/blurtextsmallradii.cpp
@@ -6,8 +6,8 @@
  */
 
 #include "gm.h"
-#include "SkBlurMaskFilter.h"
 #include "SkColor.h"
+#include "SkMaskFilter.h"
 
 // GM to check the behavior from chrome bug:745290
 DEF_SIMPLE_GM(blurSmallRadii, canvas, 100, 100) {
@@ -17,7 +17,7 @@ DEF_SIMPLE_GM(blurSmallRadii, canvas, 100, 100) {
     for (auto sigma : sigmas) {
         paint.setColor(SK_ColorBLACK);
         paint.setAntiAlias(true);
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma));
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma));
         canvas->drawString("Guest", 20, 10, paint);
 
         paint.setMaskFilter(nullptr);
diff --git a/gm/circles.cpp b/gm/circles.cpp
index 9d2eca5ba7..4c4a3a5263 100644
--- a/gm/circles.cpp
+++ b/gm/circles.cpp
@@ -7,9 +7,9 @@
 #include "gm.h"
 #include "SkBlurDrawLooper.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkColorFilter.h"
 #include "SkGradientShader.h"
+#include "SkMaskFilter.h"
 #include "SkMatrix.h"
 #include "SkRandom.h"
 #include "SkTArray.h"
@@ -52,10 +52,9 @@ protected:
         // AA with mask filter
         SkPaint p;
         p.setAntiAlias(true);
-        p.setMaskFilter(SkBlurMaskFilter::Make(
+        p.setMaskFilter(SkMaskFilter::MakeBlur(
                                kNormal_SkBlurStyle,
-                               SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
-                               SkBlurMaskFilter::kHighQuality_BlurFlag));
+                               SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5))));
         fPaints.push_back(p);
         }
 
diff --git a/gm/clip_error.cpp b/gm/clip_error.cpp
index 0a3eceb66a..49c51a7457 100644
--- a/gm/clip_error.cpp
+++ b/gm/clip_error.cpp
@@ -8,8 +8,8 @@
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkTextBlob.h"
 
 #define WIDTH 800
@@ -53,7 +53,7 @@ protected:
         const SkScalar kSigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(50));
 
         SkPaint blurPaint(paint);
-        blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, kSigma));
+        blurPaint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, kSigma));
 
         SkTextBlobBuilder builder;
 
diff --git a/gm/drawbitmaprect.cpp b/gm/drawbitmaprect.cpp
index 6b5f6d9920..e90f52df76 100644
--- a/gm/drawbitmaprect.cpp
+++ b/gm/drawbitmaprect.cpp
@@ -224,10 +224,9 @@ protected:
             paint.setFilterQuality(kLow_SkFilterQuality);
 
             srcRect.setXYWH(1, 1, 3, 3);
-            paint.setMaskFilter(SkBlurMaskFilter::Make(
+            paint.setMaskFilter(SkMaskFilter::MakeBlur(
                 kNormal_SkBlurStyle,
-                SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
-                SkBlurMaskFilter::kHighQuality_BlurFlag));
+                SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5))));
 
             sk_sp<SkImage> image(SkImage::MakeFromBitmap(bm));
             fProc(canvas, image.get(), bm, srcRect, dstRect, &paint);
diff --git a/gm/drawfilter.cpp b/gm/drawfilter.cpp
index b283c1308b..f054cc5226 100644
--- a/gm/drawfilter.cpp
+++ b/gm/drawfilter.cpp
@@ -7,9 +7,9 @@
 
 #include "gm.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkDrawFilter.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 
 #ifdef SK_SUPPORT_LEGACY_DRAWFILTER
@@ -45,9 +45,8 @@ protected:
     }
 
     void onOnceBeforeDraw() override {
-        fBlur = SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
-                                       SkBlurMask::ConvertRadiusToSigma(10.0f),
-                                       kLow_SkBlurQuality);
+        fBlur = SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
+                                       SkBlurMask::ConvertRadiusToSigma(10.0f));
     }
 
     void onDraw(SkCanvas* canvas) override {
diff --git a/gm/drawlooper.cpp b/gm/drawlooper.cpp
index 07ec8d8c3f..49f1f1279d 100644
--- a/gm/drawlooper.cpp
+++ b/gm/drawlooper.cpp
@@ -8,10 +8,10 @@
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkGraphics.h"
 #include "SkLayerDrawLooper.h"
+#include "SkMaskFilter.h"
 #include "SkRandom.h"
 
 #define WIDTH   200
@@ -78,7 +78,7 @@ private:
             paint->setStyle(gParams[i].fStyle);
             paint->setStrokeWidth(gParams[i].fWidth);
             if (gParams[i].fBlur > 0) {
-                paint->setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
+                paint->setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                          SkBlurMask::ConvertRadiusToSigma(gParams[i].fBlur)));
             }
         }
diff --git a/gm/drawregionmodes.cpp b/gm/drawregionmodes.cpp
index 88e320085a..7e4765aaec 100644
--- a/gm/drawregionmodes.cpp
+++ b/gm/drawregionmodes.cpp
@@ -7,10 +7,10 @@
 
 #include "gm.h"
 #include "SkBlurImageFilter.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkDashPathEffect.h"
 #include "SkGradientShader.h"
+#include "SkMaskFilter.h"
 #include "SkRegion.h"
 
 class DrawRegionModesGM : public skiagm::GM {
@@ -50,7 +50,7 @@ protected:
         canvas->translate(-125.0f, 125.0f);
         paint.setImageFilter(nullptr);
         SkRect occluder = SkRect::MakeEmpty();
-        paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 5.0f, occluder, 0));
+        paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 5.0f, occluder));
         canvas->drawRegion(fRegion, paint);
 
         canvas->translate(-125.0f, -125.0f);
diff --git a/gm/largeglyphblur.cpp b/gm/largeglyphblur.cpp
index fe82b5ed8c..40390cf79a 100644
--- a/gm/largeglyphblur.cpp
+++ b/gm/largeglyphblur.cpp
@@ -9,8 +9,8 @@
 #include "sk_tool_utils.h"
 
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkTextBlob.h"
 
 // This test ensures that glyphs whose point size is less than the SkGlyphCache's maxmium, but
@@ -27,7 +27,7 @@ DEF_SIMPLE_GM(largeglyphblur, canvas, 1920, 600) {
         const SkScalar kSigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(40));
 
         SkPaint blurPaint(paint);
-        blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, kSigma));
+        blurPaint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, kSigma));
 
         SkTextBlobBuilder builder;
 
diff --git a/gm/megalooper.cpp b/gm/megalooper.cpp
index 57df53aebd..e2e53e75fa 100644
--- a/gm/megalooper.cpp
+++ b/gm/megalooper.cpp
@@ -7,10 +7,10 @@
 
 #include "gm.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkLayerDrawLooper.h"
+#include "SkMaskFilter.h"
 
 // This GM tests 3 different ways of drawing four shadows around a square:
 //      just using 4 blurred rects
@@ -113,8 +113,7 @@ private:
     static sk_sp<SkMaskFilter> MakeBlur() {
         const SkScalar kBlurSigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(25));
 
-        return SkBlurMaskFilter::Make(kNormal_SkBlurStyle, kBlurSigma,
-                                      SkBlurMaskFilter::kHighQuality_BlurFlag);
+        return SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, kBlurSigma);
     }
 
     // This draws 4 blurred shadows around a single square (centered at x, y).
diff --git a/gm/occludedrrectblur.cpp b/gm/occludedrrectblur.cpp
index b43f451490..e72d2920c3 100644
--- a/gm/occludedrrectblur.cpp
+++ b/gm/occludedrrectblur.cpp
@@ -7,7 +7,7 @@
 
 #include "gm.h"
 #include "sk_tool_utils.h"
-#include "SkBlurMaskFilter.h"
+#include "SkMaskFilter.h"
 #include "SkRRect.h"
 
 static SkRect offset_center_to(const SkIRect& src, SkScalar x, SkScalar y) {
@@ -46,7 +46,7 @@ static void draw_rrect(SkCanvas* canvas, const SkRRect& rr, const SkRRect& occRR
 
     // draw the blur
     SkPaint paint;
-    paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, kBlurSigma, occRect));
+    paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, kBlurSigma, occRect));
     canvas->drawRRect(rr, paint);
 
     // draw the stroked geometry of the full occluder
diff --git a/gm/rects.cpp b/gm/rects.cpp
index d8c2fd9a42..9d7ac6dbb8 100644
--- a/gm/rects.cpp
+++ b/gm/rects.cpp
@@ -65,10 +65,9 @@ protected:
             SkPaint p;
             p.setColor(SK_ColorWHITE);
             p.setAntiAlias(true);
-            p.setMaskFilter(SkBlurMaskFilter::Make(
+            p.setMaskFilter(SkMaskFilter::MakeBlur(
                                    kNormal_SkBlurStyle,
-                                   SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
-                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
+                                   SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5))));
             fPaints.push_back(p);
         }
 
diff --git a/gm/reveal.cpp b/gm/reveal.cpp
index e58807c090..93c64ae2c2 100644
--- a/gm/reveal.cpp
+++ b/gm/reveal.cpp
@@ -8,7 +8,7 @@
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "SkAnimTimer.h"
-#include "SkBlurMaskFilter.h"
+#include "SkMaskFilter.h"
 #include "SkRRectsGaussianEdgeMaskFilter.h"
 #include "SkPath.h"
 #include "SkPathOps.h"
@@ -400,7 +400,7 @@ protected:
 
                     SkPaint blurPaint;
                     blurPaint.setAntiAlias(true);
-                    blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma));
+                    blurPaint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma));
                     canvas->drawPath(clippedPath, blurPaint);
                 } else {
                     SkASSERT(kRRectsGaussianEdge_Mode == fMode);
diff --git a/gm/samplerstress.cpp b/gm/samplerstress.cpp
index f3287437ee..25ef76c07b 100644
--- a/gm/samplerstress.cpp
+++ b/gm/samplerstress.cpp
@@ -7,8 +7,8 @@
 
 #include "gm.h"
 #include "sk_tool_utils.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkMaskFilter.h"
 #include "SkPath.h"
 #include "SkShader.h"
 
@@ -82,7 +82,7 @@ protected:
         }
 
         const SkScalar sigma = 1;
-        fMaskFilter = SkBlurMaskFilter::Make(kNormal_SkBlurStyle, sigma);
+        fMaskFilter = SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma);
     }
 
     void onDraw(SkCanvas* canvas) override {
diff --git a/gm/shadermaskfilter.cpp b/gm/shadermaskfilter.cpp
index d561967cd8..c1bee02e6d 100644
--- a/gm/shadermaskfilter.cpp
+++ b/gm/shadermaskfilter.cpp
@@ -8,9 +8,9 @@
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "SkBlendModePriv.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkImage.h"
+#include "SkMaskFilter.h"
 #include "SkShaderMaskFilter.h"
 
 static void draw_masked_image(SkCanvas* canvas, const SkImage* image, SkScalar x, SkScalar y,
@@ -58,7 +58,7 @@ DEF_SIMPLE_GM(shadermaskfilter_image, canvas, 560, 370) {
 
     auto image = GetResourceAsImage("images/mandrill_128.png");
     auto mask = GetResourceAsImage("images/color_wheel.png");
-    auto blurmf = SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 5);
+    auto blurmf = SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 5);
     auto gradmf = SkShaderMaskFilter::Make(make_shader(SkRect::MakeIWH(mask->width(),
                                                                        mask->height())));
 
@@ -166,7 +166,7 @@ DEF_SIMPLE_GM(combinemaskfilter, canvas, 560, 510) {
 
 #include "SkSurface.h"
 #include "SkBlurImageFilter.h"
-#include "SkBlurMaskFilter.h"
+#include "SkMaskFilter.h"
 static sk_sp<SkImage> make_circle_image(SkCanvas* canvas, SkScalar radius, int margin) {
     const int n = SkScalarCeilToInt(radius) * 2 + margin * 2;
     auto surf = sk_tool_utils::makeSurface(canvas, SkImageInfo::MakeN32Premul(n, n));
@@ -190,7 +190,7 @@ DEF_SIMPLE_GM(savelayer_maskfilter, canvas, 450, 675) {
 
     sk_sp<SkMaskFilter> mfs[] = {
         SkShaderMaskFilter::Make(maskImage->makeShader()),
-        SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 3.5f),
+        SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 3.5f),
         nullptr,
     };
     mfs[2] = SkMaskFilter::MakeCompose(mfs[1], mfs[0]);
diff --git a/gm/skbug1719.cpp b/gm/skbug1719.cpp
index f632852860..8f16926fc8 100644
--- a/gm/skbug1719.cpp
+++ b/gm/skbug1719.cpp
@@ -7,8 +7,8 @@
 
 #include "gm.h"
 #include "sk_tool_utils.h"
-#include "SkBlurMaskFilter.h"
 #include "SkColorFilter.h"
+#include "SkMaskFilter.h"
 #include "SkPath.h"
 
 /**
@@ -62,8 +62,7 @@ DEF_SIMPLE_GM_BG(skbug1719, canvas, 300, 100,
         paint.setAntiAlias(true);
         paint.setColor(0xFF000000);
         paint.setMaskFilter(
-            SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.78867501f,
-                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
+            SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 0.78867501f));
         paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkBlendMode::kSrcIn));
 
         canvas->clipPath(clipPath, true);
diff --git a/gm/strokedlines.cpp b/gm/strokedlines.cpp
index 402fa9b497..6e9eed7f9a 100644
--- a/gm/strokedlines.cpp
+++ b/gm/strokedlines.cpp
@@ -7,9 +7,9 @@
 
 #include "gm.h"
 #include "sk_tool_utils.h"
-#include "SkBlurMaskFilter.h"
 #include "SkDashPathEffect.h"
 #include "SkGradientShader.h"
+#include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPoint3.h"
@@ -163,8 +163,7 @@ protected:
             // blur
             SkPaint p;
             p.setColor(SK_ColorWHITE);
-            p.setMaskFilter(SkBlurMaskFilter::Make(kOuter_SkBlurStyle, 3.0f,
-                                                   SkBlurMaskFilter::kHighQuality_BlurFlag));
+            p.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle, 3.0f));
             fPaints.push_back(p);
         }
 
diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp
index 60ad4860d4..a6a77254b9 100644
--- a/gm/textbloblooper.cpp
+++ b/gm/textbloblooper.cpp
@@ -10,12 +10,12 @@
 
 #include "Sk2DPathEffect.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkColorMatrixFilter.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 #include "SkGraphics.h"
 #include "SkLayerDrawLooper.h"
+#include "SkMaskFilter.h"
 #include "SkRandom.h"
 #include "SkTextBlob.h"
 
@@ -62,7 +62,7 @@ struct LooperSettings {
 };
 
 static void mask_filter(SkPaint* paint) {
-    paint->setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
+    paint->setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
                                                 SkBlurMask::ConvertRadiusToSigma(3.f)));
 }
 
diff --git a/gm/textblobmixedsizes.cpp b/gm/textblobmixedsizes.cpp
index d5c87eeb34..7ada13a3c5 100644
--- a/gm/textblobmixedsizes.cpp
+++ b/gm/textblobmixedsizes.cpp
@@ -10,10 +10,10 @@
 
 #include "Resources.h"
 #include "SkBlurMask.h"
-#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
+#include "SkMaskFilter.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "SkSurface.h"
@@ -136,7 +136,7 @@ protected:
         // setup blur paint
         SkPaint blurPaint(paint);
         blurPaint.setColor(sk_tool_utils::color_to_565(SK_ColorBLACK));
-        blurPaint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle, kSigma));
+        blurPaint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, kSigma));
 
         for (int i = 0; i < 4; i++) {
             canvas->save();