remove xfermode from public api

BUG=skia:

GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=4020

CQ_INCLUDE_TRYBOTS=master.client.skia:Test-Ubuntu-GCC-GCE-CPU-AVX2-x86_64-Release-SKNX_NO_SIMD-Trybot

Change-Id: I19cd056f2af778f10e8c6c2b7b2735593b43dbac
Reviewed-on: https://skia-review.googlesource.com/4020
Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: Mike Klein <mtklein@chromium.org>
Commit-Queue: Mike Reed <reed@google.com>
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index 0005857..6c0049b 100644
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -190,7 +190,7 @@
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPaint grPaint;
-                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, klmSigns[c]));
@@ -322,7 +322,7 @@
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPaint grPaint;
-                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
 
                     SkAutoTUnref<GrDrawBatch> batch(
                         new BezierCubicOrConicTestBatch(gp, bounds, color, klmEqs, 1.f));
@@ -532,7 +532,7 @@
                     canvas->drawRect(bounds, boundsPaint);
 
                     GrPaint grPaint;
-                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
 
                     GrPathUtils::QuadUVMatrix DevToUV(pts);
 
diff --git a/gm/bigrrectaaeffect.cpp b/gm/bigrrectaaeffect.cpp
index 82ba7cb..be37d70 100644
--- a/gm/bigrrectaaeffect.cpp
+++ b/gm/bigrrectaaeffect.cpp
@@ -75,7 +75,7 @@
                 canvas->drawRect(testBounds, paint);
 
                 GrPaint grPaint;
-                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
 
                 SkRRect rrect = fRRect;
                 rrect.offset(SkIntToScalar(x + kGap), SkIntToScalar(y + kGap));
diff --git a/gm/blurredclippedcircle.cpp b/gm/blurredclippedcircle.cpp
index a0359c3..e2cb288 100644
--- a/gm/blurredclippedcircle.cpp
+++ b/gm/blurredclippedcircle.cpp
@@ -69,7 +69,7 @@
                                             SkBlurMaskFilter::kHighQuality_BlurFlag));
                     paint.setColorFilter(SkColorFilter::MakeModeFilter(
                                              SK_ColorRED,
-                                             SkXfermode::kSrcIn_Mode));
+                                             SkBlendMode::kSrcIn));
                     paint.setAntiAlias(true);
 
                     canvas->drawRRect(rr, paint);
diff --git a/gm/blurroundrect.cpp b/gm/blurroundrect.cpp
index 5982d06..8e5b89d 100644
--- a/gm/blurroundrect.cpp
+++ b/gm/blurroundrect.cpp
@@ -51,7 +51,7 @@
             SkLayerDrawLooper::LayerInfo info;
             info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit
                               | SkLayerDrawLooper::kColorFilter_Bit;
-            info.fColorMode = SkXfermode::kSrc_Mode;
+            info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
             info.fOffset = SkPoint::Make(SkIntToScalar(-1), SkIntToScalar(0));
             info.fPostTranslate = false;
             SkPaint* paint = looperBuilder.addLayerOnTop(info);
@@ -61,7 +61,7 @@
                     SkBlurMaskFilter::kHighQuality_BlurFlag));
             paint->setColorFilter(SkColorFilter::MakeModeFilter(
                     sk_tool_utils::color_to_565(SK_ColorLTGRAY),
-                    SkXfermode::kSrcIn_Mode));
+                    SkBlendMode::kSrcIn));
             paint->setColor(sk_tool_utils::color_to_565(SK_ColorGRAY));
         }
         {
diff --git a/gm/color4f.cpp b/gm/color4f.cpp
index c1535cc..b5cda9f 100644
--- a/gm/color4f.cpp
+++ b/gm/color4f.cpp
@@ -47,7 +47,7 @@
 }
 
 static sk_sp<SkColorFilter> make_cf2() {
-    return SkColorFilter::MakeModeFilter(0x8044CC88, SkXfermode::kSrcATop_Mode);
+    return SkColorFilter::MakeModeFilter(0x8044CC88, SkBlendMode::kSrcATop);
 }
 
 static void draw_into_canvas(SkCanvas* canvas) {
diff --git a/gm/colorfilterimagefilter.cpp b/gm/colorfilterimagefilter.cpp
index 7b54e5e..6e07ed3 100644
--- a/gm/colorfilterimagefilter.cpp
+++ b/gm/colorfilterimagefilter.cpp
@@ -39,7 +39,7 @@
 }
 
 static sk_sp<SkColorFilter> cf_make_colorize(SkColor color) {
-    return SkColorFilter::MakeModeFilter(color, SkXfermode::kSrc_Mode);
+    return SkColorFilter::MakeModeFilter(color, SkBlendMode::kSrc);
 }
 
 static void sk_gm_get_colorfilters(SkTArray<sk_sp<SkColorFilter>>* array) {
diff --git a/gm/composeshader.cpp b/gm/composeshader.cpp
index b58f91f..785f2bf 100644
--- a/gm/composeshader.cpp
+++ b/gm/composeshader.cpp
@@ -14,7 +14,7 @@
 #include "SkString.h"
 #include "SkXfermode.h"
 
-static sk_sp<SkShader> make_shader(SkXfermode::Mode mode) {
+static sk_sp<SkShader> make_shader(SkBlendMode mode) {
     SkPoint pts[2];
     SkColor colors[2];
 
@@ -30,14 +30,13 @@
     colors[1] = SkColorSetARGB(0x80, 0, 0, 0);
     auto shaderB = SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
 
-    return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB),
-                                       SkXfermode::Make(mode));
+    return SkShader::MakeComposeShader(std::move(shaderA), std::move(shaderB), mode);
 }
 
 class ComposeShaderGM : public skiagm::GM {
 public:
     ComposeShaderGM() {
-        fShader = make_shader(SkXfermode::kDstIn_Mode);
+        fShader = make_shader(SkBlendMode::kDstIn);
     }
 
 protected:
@@ -79,8 +78,8 @@
 
     void onDraw(SkCanvas* canvas) override {
         sk_sp<SkShader> shaders[] = {
-            make_shader(SkXfermode::kDstIn_Mode),
-            make_shader(SkXfermode::kSrcOver_Mode),
+            make_shader(SkBlendMode::kDstIn),
+            make_shader(SkBlendMode::kSrcOver),
         };
 
         SkPaint paint;
@@ -175,13 +174,13 @@
     }
 
     void onDraw(SkCanvas* canvas) override {
-        auto xfer(SkXfermode::Make(SkXfermode::kDstOver_Mode));
+        SkBlendMode mode = SkBlendMode::kDstOver;
 
         sk_sp<SkShader> shaders[] = {
             // gradient should appear over color bitmap
-            SkShader::MakeComposeShader(fLinearGradientShader, fColorBitmapShader, xfer),
+            SkShader::MakeComposeShader(fLinearGradientShader, fColorBitmapShader, mode),
             // gradient should appear over alpha8 bitmap colorized by the paint color
-            SkShader::MakeComposeShader(fLinearGradientShader, fAlpha8BitmapShader, xfer),
+            SkShader::MakeComposeShader(fLinearGradientShader, fAlpha8BitmapShader, mode),
         };
 
         SkPaint paint;
@@ -253,9 +252,8 @@
     sk_sp<SkImage> skMaskImage = SkImage::MakeFromBitmap(skMask);
     sk_sp<SkShader> skMaskShader = skMaskImage->makeShader(
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
-    sk_sp<SkXfermode> dstInMode = SkXfermode::Make(SkXfermode::kSrcIn_Mode);
     paint.setShader(
-        SkShader::MakeComposeShader(skMaskShader, skSrcShader, dstInMode));
+        SkShader::MakeComposeShader(skMaskShader, skSrcShader, SkBlendMode::kSrcIn));
     canvas->drawRect(r, paint);
 }
 
diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp
index f169639..d62838d 100644
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -180,7 +180,7 @@
                 }
 
                 GrPaint grPaint;
-                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
                 grPaint.addCoverageFragmentProcessor(std::move(fp));
 
                 SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(p.getBounds(), 0xff000000));
@@ -219,7 +219,7 @@
                 }
 
                 GrPaint grPaint;
-                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
                 grPaint.addCoverageFragmentProcessor(std::move(fp));
 
                 SkAutoTUnref<GrDrawBatch> batch(new PolyBoundsBatch(rect, 0xff000000));
diff --git a/gm/drawatlas.cpp b/gm/drawatlas.cpp
index 43b103c..c098e15 100644
--- a/gm/drawatlas.cpp
+++ b/gm/drawatlas.cpp
@@ -89,7 +89,7 @@
 
         canvas->drawAtlas(atlas.get(), xform, tex, N, nullptr, &paint);
         canvas->translate(0, 100);
-        canvas->drawAtlas(atlas.get(), xform, tex, colors, N, SkXfermode::kSrcIn_Mode, nullptr, &paint);
+        canvas->drawAtlas(atlas.get(), xform, tex, colors, N, SkBlendMode::kSrcIn, nullptr, &paint);
     }
 
 private:
diff --git a/gm/drawatlascolor.cpp b/gm/drawatlascolor.cpp
index bf76c48..990bdcb 100644
--- a/gm/drawatlascolor.cpp
+++ b/gm/drawatlascolor.cpp
@@ -75,38 +75,38 @@
         auto atlas = make_atlas(canvas, kAtlasSize);
 
         const struct {
-            SkXfermode::Mode fMode;
-            const char*      fLabel;
+            SkBlendMode fMode;
+            const char* fLabel;
         } gModes[] = {
-            { SkXfermode::kClear_Mode,      "Clear"     },
-            { SkXfermode::kSrc_Mode,        "Src"       },
-            { SkXfermode::kDst_Mode,        "Dst"       },
-            { SkXfermode::kSrcOver_Mode,    "SrcOver"   },
-            { SkXfermode::kDstOver_Mode,    "DstOver"   },
-            { SkXfermode::kSrcIn_Mode,      "SrcIn"     },
-            { SkXfermode::kDstIn_Mode,      "DstIn"     },
-            { SkXfermode::kSrcOut_Mode,     "SrcOut"    },
-            { SkXfermode::kDstOut_Mode,     "DstOut"    },
-            { SkXfermode::kSrcATop_Mode,    "SrcATop"   },
-            { SkXfermode::kDstATop_Mode,    "DstATop"   },
-            { SkXfermode::kXor_Mode,        "Xor"       },
-            { SkXfermode::kPlus_Mode,       "Plus"      },
-            { SkXfermode::kModulate_Mode,   "Mod"       },
-            { SkXfermode::kScreen_Mode,     "Screen"    },
-            { SkXfermode::kOverlay_Mode,    "Overlay"   },
-            { SkXfermode::kDarken_Mode,     "Darken"    },
-            { SkXfermode::kLighten_Mode,    "Lighten"   },
-            { SkXfermode::kColorDodge_Mode, "Dodge"     },
-            { SkXfermode::kColorBurn_Mode,  "Burn"      },
-            { SkXfermode::kHardLight_Mode,  "Hard"      },
-            { SkXfermode::kSoftLight_Mode,  "Soft"      },
-            { SkXfermode::kDifference_Mode, "Diff"      },
-            { SkXfermode::kExclusion_Mode,  "Exclusion" },
-            { SkXfermode::kMultiply_Mode,   "Multiply"  },
-            { SkXfermode::kHue_Mode,        "Hue"       },
-            { SkXfermode::kSaturation_Mode, "Sat"       },
-            { SkXfermode::kColor_Mode,      "Color"     },
-            { SkXfermode::kLuminosity_Mode, "Luminosity"},
+            { SkBlendMode::kClear,      "Clear"     },
+            { SkBlendMode::kSrc,        "Src"       },
+            { SkBlendMode::kDst,        "Dst"       },
+            { SkBlendMode::kSrcOver,    "SrcOver"   },
+            { SkBlendMode::kDstOver,    "DstOver"   },
+            { SkBlendMode::kSrcIn,      "SrcIn"     },
+            { SkBlendMode::kDstIn,      "DstIn"     },
+            { SkBlendMode::kSrcOut,     "SrcOut"    },
+            { SkBlendMode::kDstOut,     "DstOut"    },
+            { SkBlendMode::kSrcATop,    "SrcATop"   },
+            { SkBlendMode::kDstATop,    "DstATop"   },
+            { SkBlendMode::kXor,        "Xor"       },
+            { SkBlendMode::kPlus,       "Plus"      },
+            { SkBlendMode::kModulate,   "Mod"       },
+            { SkBlendMode::kScreen,     "Screen"    },
+            { SkBlendMode::kOverlay,    "Overlay"   },
+            { SkBlendMode::kDarken,     "Darken"    },
+            { SkBlendMode::kLighten,    "Lighten"   },
+            { SkBlendMode::kColorDodge, "Dodge"     },
+            { SkBlendMode::kColorBurn,  "Burn"      },
+            { SkBlendMode::kHardLight,  "Hard"      },
+            { SkBlendMode::kSoftLight,  "Soft"      },
+            { SkBlendMode::kDifference, "Diff"      },
+            { SkBlendMode::kExclusion,  "Exclusion" },
+            { SkBlendMode::kMultiply,   "Multiply"  },
+            { SkBlendMode::kHue,        "Hue"       },
+            { SkBlendMode::kSaturation, "Sat"       },
+            { SkBlendMode::kColor,      "Color"     },
+            { SkBlendMode::kLuminosity, "Luminosity"},
         };
 
         SkColor gColors[] = {
diff --git a/gm/drawlooper.cpp b/gm/drawlooper.cpp
index df8256f..8275939 100644
--- a/gm/drawlooper.cpp
+++ b/gm/drawlooper.cpp
@@ -73,7 +73,7 @@
 
         SkLayerDrawLooper::LayerInfo info;
         info.fPaintBits = SkLayerDrawLooper::kStyle_Bit | SkLayerDrawLooper::kMaskFilter_Bit;
-        info.fColorMode = SkXfermode::kSrc_Mode;
+        info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(gParams); i++) {
             info.fOffset.set(gParams[i].fOffset, gParams[i].fOffset);
diff --git a/gm/dropshadowimagefilter.cpp b/gm/dropshadowimagefilter.cpp
index 370b569..fff318e 100644
--- a/gm/dropshadowimagefilter.cpp
+++ b/gm/dropshadowimagefilter.cpp
@@ -87,7 +87,7 @@
         };
 
         sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorMAGENTA,
-                                                              SkXfermode::kSrcIn_Mode));
+                                                              SkBlendMode::kSrcIn));
         sk_sp<SkImageFilter> cfif(SkColorFilterImageFilter::Make(std::move(cf), nullptr));
         SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
                                          SkImageFilter::CropRect::kHasAll_CropEdge);
diff --git a/gm/emboss.cpp b/gm/emboss.cpp
index e7c5800..c4c6209 100644
--- a/gm/emboss.cpp
+++ b/gm/emboss.cpp
@@ -49,7 +49,7 @@
 
         // this combination of emboss+colorfilter used to crash -- so we exercise it to
         // confirm that we have a fix.
-        paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkXfermode::kSrcATop_Mode));
+        paint.setColorFilter(SkColorFilter::MakeModeFilter(0xFFFF0000, SkBlendMode::kSrcATop));
         canvas->translate(bm.width() + SkIntToScalar(10), 0);
         canvas->drawBitmap(bm, 10, 10, &paint);
     }
diff --git a/gm/gamut.cpp b/gm/gamut.cpp
index a54214e..9f45d6e 100644
--- a/gm/gamut.cpp
+++ b/gm/gamut.cpp
@@ -104,7 +104,7 @@
             SkPoint::Make(0, gScalarSize)
         };
         canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, vertices, nullptr, fColors,
-                             nullptr, nullptr, 0, paint);
+                             SkBlendMode::kModulate, nullptr, 0, paint);
     }
     const char* label() override {
         return "Vertices";
diff --git a/gm/imagefiltersbase.cpp b/gm/imagefiltersbase.cpp
index b30267a..440f6b2 100644
--- a/gm/imagefiltersbase.cpp
+++ b/gm/imagefiltersbase.cpp
@@ -194,7 +194,7 @@
             draw_bitmap,
         };
 
-        auto cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode);
+        auto cf = SkColorFilter::MakeModeFilter(SK_ColorRED, SkBlendMode::kSrcIn);
         sk_sp<SkImageFilter> filters[] = {
             nullptr,
             IdentityImageFilter::Make(nullptr),
@@ -318,7 +318,7 @@
     ImageFiltersText_CF() : ImageFiltersTextBaseGM("color") {}
 
     void installFilter(SkPaint* paint) override {
-        paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrcIn_Mode));
+        paint->setColorFilter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkBlendMode::kSrcIn));
     }
 };
 DEF_GM( return new ImageFiltersText_CF; )
diff --git a/gm/imagefilterscropped.cpp b/gm/imagefilterscropped.cpp
index 0f36c83..e5702aa 100644
--- a/gm/imagefilterscropped.cpp
+++ b/gm/imagefilterscropped.cpp
@@ -115,7 +115,7 @@
         };
 
         sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
-                                                              SkXfermode::kSrcIn_Mode));
+                                                              SkBlendMode::kSrcIn));
         SkImageFilter::CropRect cropRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 44, 44)),
                                          SkImageFilter::CropRect::kHasAll_CropEdge);
         SkImageFilter::CropRect bogusRect(SkRect::Make(SkIRect::MakeXYWH(-100, -100, 10, 10)),
@@ -144,7 +144,7 @@
             SkErodeImageFilter::Make(8, 8, nullptr, &cropRect),
             SkMergeImageFilter::Make(nullptr,
                                      std::move(cfOffset),
-                                     SkXfermode::kSrcOver_Mode,
+                                     SkBlendMode::kSrcOver,
                                      &cropRect),
             SkBlurImageFilter::Make(8.0f, 8.0f, nullptr, &bogusRect),
             SkColorFilterImageFilter::Make(cf, nullptr, &bogusRect),
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index 2d27728..fd4d5cf 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -45,12 +45,13 @@
         {
             sk_sp<SkImageFilter> bitmapSource(SkImageSource::Make(fImage));
             sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
-                                                                  SkXfermode::kSrcIn_Mode));
+                                                                  SkBlendMode::kSrcIn));
             sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, std::move(bitmapSource)));
             sk_sp<SkImageFilter> erode(SkErodeImageFilter::Make(4, 4, blur));
             sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Make(std::move(cf),
                                                                       std::move(erode)));
-            sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color));
+            sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color,
+                                                                SkBlendMode::kSrcOver));
 
             SkPaint paint;
             paint.setImageFilter(std::move(merge));
@@ -143,9 +144,9 @@
         {
             // Test that crop offsets are absolute, not relative to the parent's crop rect.
             sk_sp<SkColorFilter> cf1(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
-                                                                   SkXfermode::kSrcIn_Mode));
+                                                                   SkBlendMode::kSrcIn));
             sk_sp<SkColorFilter> cf2(SkColorFilter::MakeModeFilter(SK_ColorGREEN,
-                                                                   SkXfermode::kSrcIn_Mode));
+                                                                   SkBlendMode::kSrcIn));
             SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
                                                                SkIntToScalar(80), SkIntToScalar(80)));
             SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
diff --git a/gm/imagemakewithfilter.cpp b/gm/imagemakewithfilter.cpp
index 9620e0d..48b1740 100644
--- a/gm/imagemakewithfilter.cpp
+++ b/gm/imagemakewithfilter.cpp
@@ -44,7 +44,7 @@
     SkISize onISize() override { return SkISize::Make(440, 530); }
 
     void onDraw(SkCanvas* canvas) override {
-        auto cf = SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode);
+        auto cf = SkColorFilter::MakeModeFilter(SK_ColorGREEN, SkBlendMode::kSrc);
         sk_sp<SkImageFilter> filters[] = {
             SkColorFilterImageFilter::Make(std::move(cf), nullptr),
             SkBlurImageFilter::Make(2.0f, 2.0f, nullptr),
diff --git a/gm/megalooper.cpp b/gm/megalooper.cpp
index 86dd617..fd8757b 100644
--- a/gm/megalooper.cpp
+++ b/gm/megalooper.cpp
@@ -167,7 +167,7 @@
 
         info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit |
                           SkLayerDrawLooper::kMaskFilter_Bit;
-        info.fColorMode = SkXfermode::kSrc_Mode;
+        info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
         info.fOffset.set(xOff, yOff);
         info.fPostTranslate = false;
 
@@ -175,7 +175,7 @@
 
         paint->setMaskFilter(MakeBlur());
 
-        paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkXfermode::kSrcIn_Mode));
+        paint->setColorFilter(SkColorFilter::MakeModeFilter(color, SkBlendMode::kSrcIn));
 
         return looperBuilder.detach();
     }
@@ -210,7 +210,7 @@
 
         info.fPaintBits = SkLayerDrawLooper::kColorFilter_Bit |
                           SkLayerDrawLooper::kMaskFilter_Bit;
-        info.fColorMode = SkXfermode::kSrc_Mode;
+        info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
         info.fPostTranslate = false;
 
         SkPaint* paint;
@@ -221,8 +221,7 @@
 
             paint->setMaskFilter(MakeBlur());
 
-            paint->setColorFilter(SkColorFilter::MakeModeFilter(gColors[i],
-                                                                SkXfermode::kSrcIn_Mode));
+            paint->setColorFilter(SkColorFilter::MakeModeFilter(gColors[i], SkBlendMode::kSrcIn));
         }
 
         return looperBuilder.detach();
diff --git a/gm/modecolorfilters.cpp b/gm/modecolorfilters.cpp
index ae926ef..cc54e76 100644
--- a/gm/modecolorfilters.cpp
+++ b/gm/modecolorfilters.cpp
@@ -99,21 +99,21 @@
         // used with shaders
         SkColor alphas[] = {0xFFFFFFFF, 0x80808080};
 
-        SkXfermode::Mode modes[]  = { // currently just doing the Modes expressible as Coeffs
-            SkXfermode::kClear_Mode,
-            SkXfermode::kSrc_Mode,
-            SkXfermode::kDst_Mode,
-            SkXfermode::kSrcOver_Mode,
-            SkXfermode::kDstOver_Mode,
-            SkXfermode::kSrcIn_Mode,
-            SkXfermode::kDstIn_Mode,
-            SkXfermode::kSrcOut_Mode,
-            SkXfermode::kDstOut_Mode,
-            SkXfermode::kSrcATop_Mode,
-            SkXfermode::kDstATop_Mode,
-            SkXfermode::kXor_Mode,
-            SkXfermode::kPlus_Mode,
-            SkXfermode::kModulate_Mode,
+        const SkBlendMode modes[]  = { // currently just doing the Modes expressible as Coeffs
+            SkBlendMode::kClear,
+            SkBlendMode::kSrc,
+            SkBlendMode::kDst,
+            SkBlendMode::kSrcOver,
+            SkBlendMode::kDstOver,
+            SkBlendMode::kSrcIn,
+            SkBlendMode::kDstIn,
+            SkBlendMode::kSrcOut,
+            SkBlendMode::kDstOut,
+            SkBlendMode::kSrcATop,
+            SkBlendMode::kDstATop,
+            SkBlendMode::kXor,
+            SkBlendMode::kPlus,
+            SkBlendMode::kModulate,
         };
 
         SkPaint paint;
diff --git a/gm/multipicturedraw.cpp b/gm/multipicturedraw.cpp
index d7d81f2..35f4c12 100644
--- a/gm/multipicturedraw.cpp
+++ b/gm/multipicturedraw.cpp
@@ -412,7 +412,7 @@
             step.fY = SkIntToScalar(y*kTileHeight);
             step.fPaint = new SkPaint;
             step.fPaint->setColorFilter(
-                SkColorFilter::MakeModeFilter(colors[x][y], SkXfermode::kModulate_Mode));
+                SkColorFilter::MakeModeFilter(colors[x][y], SkBlendMode::kModulate));
 
             step.fSurf = create_compat_surface(finalCanvas, kTileWidth, kTileHeight);
 
diff --git a/gm/patch.cpp b/gm/patch.cpp
index 6b2d298..c9831c4 100644
--- a/gm/patch.cpp
+++ b/gm/patch.cpp
@@ -85,36 +85,34 @@
             {0.0f, 0.0f}, {100.0f, 0.0f}, {100.0f,100.0f}, {0.0f, 100.0f}}
         ;
 
-        const SkXfermode::Mode modes[] = {
-            SkXfermode::kSrc_Mode,
-            SkXfermode::kDst_Mode,
-            SkXfermode::kModulate_Mode,
+        const SkBlendMode modes[] = {
+            SkBlendMode::kSrc,
+            SkBlendMode::kDst,
+            SkBlendMode::kModulate,
         };
 
         sk_sp<SkShader> shader(make_shader());
 
         canvas->save();
         for (int y = 0; y < 3; y++) {
-            sk_sp<SkXfermode> xfer(SkXfermode::Make(modes[y]));
-
             for (int x = 0; x < 4; x++) {
                 canvas->save();
                 canvas->translate(x * 350.0f, y * 350.0f);
                 switch (x) {
                     case 0:
-                        canvas->drawPatch(cubics, nullptr, nullptr, xfer, paint);
+                        canvas->drawPatch(cubics, nullptr, nullptr, modes[y], paint);
                         break;
                     case 1:
-                        canvas->drawPatch(cubics, colors, nullptr, xfer, paint);
+                        canvas->drawPatch(cubics, colors, nullptr, modes[y], paint);
                         break;
                     case 2:
                         paint.setShader(shader);
-                        canvas->drawPatch(cubics, nullptr, texCoords, xfer, paint);
+                        canvas->drawPatch(cubics, nullptr, texCoords, modes[y], paint);
                         paint.setShader(nullptr);
                         break;
                     case 3:
                         paint.setShader(shader);
-                        canvas->drawPatch(cubics, colors, texCoords, xfer, paint);
+                        canvas->drawPatch(cubics, colors, texCoords, modes[y], paint);
                         paint.setShader(nullptr);
                         break;
                     default:
diff --git a/gm/patchgrid.cpp b/gm/patchgrid.cpp
index a36e58f..6f32231 100644
--- a/gm/patchgrid.cpp
+++ b/gm/patchgrid.cpp
@@ -109,7 +109,7 @@
         constexpr int kCols = 4;
 
         canvas->scale(3, 3);
-        SkPatchGrid grid(kRows, kCols, SkPatchGrid::kColors_VertexType, nullptr);
+        SkPatchGrid grid(kRows, kCols, SkPatchGrid::kColors_VertexType);
         for (int i = 0; i < kRows; i++) {
             for (int j = 0; j < kCols; j++) {
                 SkPoint points[12];
diff --git a/gm/rrects.cpp b/gm/rrects.cpp
index f012145..c252ec6 100644
--- a/gm/rrects.cpp
+++ b/gm/rrects.cpp
@@ -103,7 +103,7 @@
                     if (kEffect_Type == fType) {
 #if SK_SUPPORT_GPU
                         GrPaint grPaint;
-                        grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                        grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
 
                         SkRRect rrect = fRRects[curRRect];
                         rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
diff --git a/gm/skbug1719.cpp b/gm/skbug1719.cpp
index 3c49aaa..9d6d98b 100644
--- a/gm/skbug1719.cpp
+++ b/gm/skbug1719.cpp
@@ -63,7 +63,7 @@
         paint.setMaskFilter(
             SkBlurMaskFilter::Make(kNormal_SkBlurStyle, 0.78867501f,
                                    SkBlurMaskFilter::kHighQuality_BlurFlag));
-        paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkXfermode::kSrcIn_Mode));
+        paint.setColorFilter(SkColorFilter::MakeModeFilter(0xBFFFFFFF, SkBlendMode::kSrcIn));
 
         canvas->clipPath(clipPath, true);
         canvas->drawPath(drawPath, paint);
diff --git a/gm/tablecolorfilter.cpp b/gm/tablecolorfilter.cpp
index 26a3c2c..0f870c6 100644
--- a/gm/tablecolorfilter.cpp
+++ b/gm/tablecolorfilter.cpp
@@ -198,12 +198,12 @@
         COLOR_COUNT = 3,
         MODE_COUNT = 4,
     };
-    const SkColor*          fColors;
-    const SkXfermode::Mode* fModes;
-    SkString                fName;
+    const SkColor*      fColors;
+    const SkBlendMode*  fModes;
+    SkString            fName;
 
 public:
-    ComposeColorFilterGM(const SkColor colors[], const SkXfermode::Mode modes[],
+    ComposeColorFilterGM(const SkColor colors[], const SkBlendMode modes[],
                          const char suffix[])
         : fColors(colors), fModes(modes)
     {
@@ -276,19 +276,19 @@
 };
 
 const SkColor gColors0[] = { SK_ColorCYAN, SK_ColorMAGENTA, SK_ColorYELLOW };
-const SkXfermode::Mode gModes0[] = {
-    SkXfermode::kOverlay_Mode,
-    SkXfermode::kDarken_Mode,
-    SkXfermode::kColorBurn_Mode,
-    SkXfermode::kExclusion_Mode,
+const SkBlendMode gModes0[] = {
+    SkBlendMode::kOverlay,
+    SkBlendMode::kDarken,
+    SkBlendMode::kColorBurn,
+    SkBlendMode::kExclusion,
 };
 DEF_GM( return new ComposeColorFilterGM(gColors0, gModes0, "wacky"); )
 
 const SkColor gColors1[] = { 0x80FF0000, 0x8000FF00, 0x800000FF };
-const SkXfermode::Mode gModes1[] = {
-    SkXfermode::kSrcOver_Mode,
-    SkXfermode::kXor_Mode,
-    SkXfermode::kDstOut_Mode,
-    SkXfermode::kSrcATop_Mode,
+const SkBlendMode gModes1[] = {
+    SkBlendMode::kSrcOver,
+    SkBlendMode::kXor,
+    SkBlendMode::kDstOut,
+    SkBlendMode::kSrcATop,
 };
 DEF_GM( return new ComposeColorFilterGM(gColors1, gModes1, "alpha"); )
diff --git a/gm/texdata.cpp b/gm/texdata.cpp
index c269448..05441ac 100644
--- a/gm/texdata.cpp
+++ b/gm/texdata.cpp
@@ -87,7 +87,7 @@
         GrFixedClip clip(SkIRect::MakeWH(2*S, 2*S));
 
         GrPaint paint;
-        paint.setPorterDuffXPFactory(SkXfermode::kSrcOver_Mode);
+        paint.setPorterDuffXPFactory(SkBlendMode::kSrcOver);
 
         SkMatrix vm;
         if (i) {
diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp
index 37eae66..29f9756 100644
--- a/gm/textbloblooper.cpp
+++ b/gm/textbloblooper.cpp
@@ -115,7 +115,7 @@
     SkLayerDrawLooper::LayerInfo info;
     info.fPaintBits = bits;
 
-    info.fColorMode = SkXfermode::kSrc_Mode;
+    info.fColorMode = (SK_XFERMODE_MODE_PARAM)SkBlendMode::kSrc;
 
     for (size_t i = 0; i < size; i++) {
         info.fOffset.set(settings[i].fOffset, settings[i].fOffset);
diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp
index 70d1420..06c6518 100644
--- a/gm/texturedomaineffect.cpp
+++ b/gm/texturedomaineffect.cpp
@@ -114,7 +114,7 @@
                 for (int m = 0; m < GrTextureDomain::kModeCount; ++m) {
                     GrTextureDomain::Mode mode = (GrTextureDomain::Mode) m;
                     GrPaint grPaint;
-                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                    grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
                     sk_sp<GrFragmentProcessor> fp(
                         GrTextureDomainEffect::Make(texture, nullptr, textureMatrices[tm],
                                                 GrTextureDomain::MakeTexelDomain(texture,
diff --git a/gm/tileimagefilter.cpp b/gm/tileimagefilter.cpp
index 58542b7..c7d3e37 100644
--- a/gm/tileimagefilter.cpp
+++ b/gm/tileimagefilter.cpp
@@ -114,7 +114,7 @@
         dstRect = SkRect::MakeXYWH(0, 0, 100, 100);
         SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(5, 5, 40, 40));
         sk_sp<SkColorFilter> greenCF = SkColorFilter::MakeModeFilter(SK_ColorGREEN,
-                                                                     SkXfermode::kSrc_Mode);
+                                                                     SkBlendMode::kSrc);
         sk_sp<SkImageFilter> green(SkColorFilterImageFilter::Make(std::move(greenCF),
                                                                   nullptr,
                                                                   &cropRect));
diff --git a/gm/vertices.cpp b/gm/vertices.cpp
index 2d6e37d..da79d7d 100644
--- a/gm/vertices.cpp
+++ b/gm/vertices.cpp
@@ -27,7 +27,7 @@
 }
 
 static sk_sp<SkColorFilter> make_color_filter() {
-    return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkXfermode::kDarken_Mode);
+    return SkColorFilter::MakeModeFilter(0xFFAABBCC, SkBlendMode::kDarken);
 }
 
 class VerticesGM : public skiagm::GM {
@@ -117,36 +117,36 @@
             { fColors,  fTexs  , fShader2, fColorFilter, 0x80 },
         };
 
-        const SkXfermode::Mode modes[] = {
-            SkXfermode::kClear_Mode,
-            SkXfermode::kSrc_Mode,
-            SkXfermode::kDst_Mode,
-            SkXfermode::kSrcOver_Mode,
-            SkXfermode::kDstOver_Mode,
-            SkXfermode::kSrcIn_Mode,
-            SkXfermode::kDstIn_Mode,
-            SkXfermode::kSrcOut_Mode,
-            SkXfermode::kDstOut_Mode,
-            SkXfermode::kSrcATop_Mode,
-            SkXfermode::kDstATop_Mode,
-            SkXfermode::kXor_Mode,
-            SkXfermode::kPlus_Mode,
-            SkXfermode::kModulate_Mode,
-            SkXfermode::kScreen_Mode,
-            SkXfermode::kOverlay_Mode,
-            SkXfermode::kDarken_Mode,
-            SkXfermode::kLighten_Mode,
-            SkXfermode::kColorDodge_Mode,
-            SkXfermode::kColorBurn_Mode,
-            SkXfermode::kHardLight_Mode,
-            SkXfermode::kSoftLight_Mode,
-            SkXfermode::kDifference_Mode,
-            SkXfermode::kExclusion_Mode,
-            SkXfermode::kMultiply_Mode,
-            SkXfermode::kHue_Mode,
-            SkXfermode::kSaturation_Mode,
-            SkXfermode::kColor_Mode,
-            SkXfermode::kLuminosity_Mode,
+        const SkBlendMode modes[] = {
+            SkBlendMode::kClear,
+            SkBlendMode::kSrc,
+            SkBlendMode::kDst,
+            SkBlendMode::kSrcOver,
+            SkBlendMode::kDstOver,
+            SkBlendMode::kSrcIn,
+            SkBlendMode::kDstIn,
+            SkBlendMode::kSrcOut,
+            SkBlendMode::kDstOut,
+            SkBlendMode::kSrcATop,
+            SkBlendMode::kDstATop,
+            SkBlendMode::kXor,
+            SkBlendMode::kPlus,
+            SkBlendMode::kModulate,
+            SkBlendMode::kScreen,
+            SkBlendMode::kOverlay,
+            SkBlendMode::kDarken,
+            SkBlendMode::kLighten,
+            SkBlendMode::kColorDodge,
+            SkBlendMode::kColorBurn,
+            SkBlendMode::kHardLight,
+            SkBlendMode::kSoftLight,
+            SkBlendMode::kDifference,
+            SkBlendMode::kExclusion,
+            SkBlendMode::kMultiply,
+            SkBlendMode::kHue,
+            SkBlendMode::kSaturation,
+            SkBlendMode::kColor,
+            SkBlendMode::kLuminosity,
         };
 
         SkPaint paint;
@@ -154,7 +154,6 @@
         canvas->translate(4, 4);
         int x = 0;
         for (size_t j = 0; j < SK_ARRAY_COUNT(modes); ++j) {
-            auto xfer = SkXfermode::Make(modes[j]);
             canvas->save();
             for (size_t i = 0; i < SK_ARRAY_COUNT(rec); ++i) {
                 paint.setShader(rec[i].fShader);
@@ -164,7 +163,7 @@
                 canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode,
                                      SK_ARRAY_COUNT(fPts), fPts,
                                      rec[i].fTexs, rec[i].fColors,
-                                     xfer, fan, SK_ARRAY_COUNT(fan), paint);
+                                     modes[j], fan, SK_ARRAY_COUNT(fan), paint);
                 canvas->translate(40, 0);
                 ++x;
             }
diff --git a/gm/yuvtorgbeffect.cpp b/gm/yuvtorgbeffect.cpp
index d094bdf..34f5e2b 100644
--- a/gm/yuvtorgbeffect.cpp
+++ b/gm/yuvtorgbeffect.cpp
@@ -114,7 +114,7 @@
 
             for (int i = 0; i < 6; ++i) {
                 GrPaint grPaint;
-                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+                grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
                 sk_sp<GrFragmentProcessor> fp(GrYUVEffect::MakeYUVToRGB(
                     texture[indices[i][0]], texture[indices[i][1]], texture[indices[i][2]], sizes,
                     static_cast<SkYUVColorSpace>(space), false));
@@ -227,7 +227,7 @@
             SkScalar x = kDrawPad + kTestPad;
 
             GrPaint grPaint;
-            grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkXfermode::kSrc_Mode));
+            grPaint.setXPFactory(GrPorterDuffXPFactory::Make(SkBlendMode::kSrc));
             sk_sp<GrFragmentProcessor> fp(
                 GrYUVEffect::MakeYUVToRGB(texture[0], texture[1], texture[2], sizes,
                                           static_cast<SkYUVColorSpace>(space), true));