replace SkXfermode obj with SkBlendMode enum in paints

BUG=skia:5814

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

Change-Id: I4fb489ba6b3f77b458f7e4a99f79c7ad10859135
Reviewed-on: https://skia-review.googlesource.com/2714
Reviewed-by: Florin Malita <fmalita@chromium.org>
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Mike Reed <reed@google.com>

32 files changed, 286 insertions, 295 deletions

diff --git a/gm/aaclip.cpp b/gm/aaclip.cpp
index 26a25c1385..f00a4cdcec 100644
--- a/gm/aaclip.cpp
+++ b/gm/aaclip.cpp
@@ -11,7 +11,7 @@
 
 static void do_draw(SkCanvas* canvas, const SkRect& r) {
     SkPaint paint;
-    paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+    paint.setBlendMode(SkBlendMode::kSrc);
     paint.setColor(0x800000FF);
     canvas->drawRect(r, paint);
 }
diff --git a/gm/aarectmodes.cpp b/gm/aarectmodes.cpp
index 6e9f4bf600..ebc47c2da2 100644
--- a/gm/aarectmodes.cpp
+++ b/gm/aarectmodes.cpp
@@ -59,21 +59,21 @@ static void test4(SkCanvas* canvas) {
 }
 
 constexpr 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"       },
+    { 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"       },
 };
 
 const int gWidth = 64;
@@ -81,7 +81,7 @@ const int gHeight = 64;
 const SkScalar W = SkIntToScalar(gWidth);
 const SkScalar H = SkIntToScalar(gHeight);
 
-static SkScalar drawCell(SkCanvas* canvas, sk_sp<SkXfermode> mode, SkAlpha a0, SkAlpha a1) {
+static SkScalar drawCell(SkCanvas* canvas, SkBlendMode mode, SkAlpha a0, SkAlpha a1) {
 
     SkPaint paint;
     paint.setAntiAlias(true);
@@ -95,7 +95,7 @@ static SkScalar drawCell(SkCanvas* canvas, sk_sp<SkXfermode> mode, SkAlpha a0, S
 
     paint.setColor(SK_ColorRED);
     paint.setAlpha(a1);
-    paint.setXfermode(std::move(mode));
+    paint.setBlendMode(mode);
 
     SkScalar offset = SK_Scalar1 / 3;
     SkRect rect = SkRect::MakeXYWH(W / 4 + offset,
@@ -155,7 +155,7 @@ namespace skiagm {
                     }
                     canvas->drawRect(bounds, fBGPaint);
                     canvas->saveLayer(&bounds, nullptr);
-                    SkScalar dy = drawCell(canvas, SkXfermode::Make(gModes[i].fMode),
+                    SkScalar dy = drawCell(canvas, gModes[i].fMode,
                                            gAlphaValue[alpha & 1],
                                            gAlphaValue[alpha & 2]);
                     canvas->restore();
diff --git a/gm/aaxfermodes.cpp b/gm/aaxfermodes.cpp
index 678a8379e3..7106ce8174 100644
--- a/gm/aaxfermodes.cpp
+++ b/gm/aaxfermodes.cpp
@@ -121,7 +121,7 @@ protected:
                 if (firstMode + m > SkXfermode::kLastMode) {
                     break;
                 }
-                SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(firstMode + m);
+                SkBlendMode mode = static_cast<SkBlendMode>(firstMode + m);
                 canvas->save();
 
                 if (kShape_Pass == drawingPass) {
@@ -144,7 +144,7 @@ protected:
                                         10);
                             } else {
                                 SkASSERT(kBackground_Pass == drawingPass);
-                                canvas->drawColor(kBGColor, SkXfermode::kSrc_Mode);
+                                canvas->drawColor(kBGColor, SkBlendMode::kSrc);
                             }
                             canvas->restore();
                         } else {
@@ -190,18 +190,17 @@ protected:
         canvas->restore();
     }
 
-    void drawModeName(SkCanvas* canvas, SkXfermode::Mode mode) {
-        const char* modeName = mode <= SkXfermode::kLastMode ? SkXfermode::ModeName(mode)
-                                                             : "Arithmetic";
+    void drawModeName(SkCanvas* canvas, SkBlendMode mode) {
+        const char* modeName = SkXfermode::ModeName(mode);
         fLabelPaint.setTextAlign(SkPaint::kRight_Align);
         canvas->drawText(modeName, strlen(modeName), kLabelSpacing - kShapeSize / 4,
                          fLabelPaint.getTextSize() / 4, fLabelPaint);
     }
 
-    void setupShapePaint(SkCanvas* canvas, GrColor color, SkXfermode::Mode mode, SkPaint* paint) {
+    void setupShapePaint(SkCanvas* canvas, GrColor color, SkBlendMode mode, SkPaint* paint) {
         paint->setColor(color);
 
-        if (mode == SkXfermode::kPlus_Mode) {
+        if (mode == SkBlendMode::kPlus) {
             // Check for overflow, otherwise we might get confusing AA artifacts.
             int maxSum = SkTMax(SkTMax(SkColorGetA(kBGColor) + SkColorGetA(color),
                                        SkColorGetR(kBGColor) + SkColorGetR(color)),
@@ -211,7 +210,7 @@ protected:
             if (maxSum > 255) {
                 SkPaint dimPaint;
                 dimPaint.setAntiAlias(false);
-                dimPaint.setXfermodeMode(SkXfermode::kDstIn_Mode);
+                dimPaint.setBlendMode(SkBlendMode::kDstIn);
                 if (255 != paint->getAlpha()) {
                     // Dim the src and dst colors.
                     dimPaint.setARGB(255 * 255 / maxSum, 0, 0, 0);
@@ -227,11 +226,11 @@ protected:
         }
     }
 
-    void drawShape(SkCanvas* canvas, Shape shape, const SkPaint& paint, SkXfermode::Mode mode) {
-        SkASSERT(mode <= SkXfermode::kLastMode);
+    void drawShape(SkCanvas* canvas, Shape shape, const SkPaint& paint, SkBlendMode mode) {
+        SkASSERT(mode <= SkBlendMode::kLastMode);
         SkPaint shapePaint(paint);
         shapePaint.setAntiAlias(kSquare_Shape != shape);
-        shapePaint.setXfermodeMode(mode);
+        shapePaint.setBlendMode(mode);
 
         switch (shape) {
             case kSquare_Shape:
@@ -249,7 +248,7 @@ protected:
 
             case kOval_Shape:
                 canvas->save();
-                canvas->rotate(static_cast<SkScalar>((511 * mode + 257) % 360));
+                canvas->rotate(static_cast<SkScalar>((511 * (int)mode + 257) % 360));
                 canvas->drawPath(fOval, shapePaint);
                 canvas->restore();
                 break;
diff --git a/gm/bitmaprect.cpp b/gm/bitmaprect.cpp
index 2a813004df..06bf36a91d 100644
--- a/gm/bitmaprect.cpp
+++ b/gm/bitmaprect.cpp
@@ -201,7 +201,7 @@ protected:
     void onDraw(SkCanvas* canvas) override {
         SkPaint paint;
         paint.setAlpha(128);
-        paint.setXfermode(SkXfermode::Make(SkXfermode::kXor_Mode));
+        paint.setBlendMode(SkBlendMode::kXor);
 
         SkRect srcR1 = { 0.0f, 0.0f, 4096.0f, 2040.0f };
         SkRect dstR1 = { 10.1f, 10.1f, 629.9f, 400.9f };
diff --git a/gm/blurredclippedcircle.cpp b/gm/blurredclippedcircle.cpp
index a0870649da..a0359c367a 100644
--- a/gm/blurredclippedcircle.cpp
+++ b/gm/blurredclippedcircle.cpp
@@ -34,7 +34,7 @@ protected:
     void onDraw(SkCanvas* canvas) override {
         SkPaint whitePaint;
         whitePaint.setColor(SK_ColorWHITE);
-        whitePaint.setXfermode(SkXfermode::Make(SkXfermode::kSrc_Mode));
+        whitePaint.setBlendMode(SkBlendMode::kSrc);
         whitePaint.setAntiAlias(true);
 
         // This scale exercises precision limits in the circle blur effect (crbug.com/560651)
diff --git a/gm/colormatrix.cpp b/gm/colormatrix.cpp
index 202f72ab12..f6d51fcbb5 100644
--- a/gm/colormatrix.cpp
+++ b/gm/colormatrix.cpp
@@ -77,7 +77,7 @@ protected:
         SkPaint paint;
         SkColorMatrix matrix;
 
-        paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+        paint.setBlendMode(SkBlendMode::kSrc);
         const SkImage* bmps[] = { fSolidImg.get(), fTransparentImg.get() };
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(bmps); ++i) {
diff --git a/gm/colortypexfermode.cpp b/gm/colortypexfermode.cpp
index 554282fadf..9b715ef78c 100644
--- a/gm/colortypexfermode.cpp
+++ b/gm/colortypexfermode.cpp
@@ -57,39 +57,39 @@ protected:
         canvas->translate(SkIntToScalar(10), SkIntToScalar(20));
 
         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,     "Modulate"    },
-            { SkXfermode::kScreen_Mode,       "Screen"      },
-            { SkXfermode::kOverlay_Mode,      "Overlay"     },
-            { SkXfermode::kDarken_Mode,       "Darken"      },
-            { SkXfermode::kLighten_Mode,      "Lighten"     },
-            { SkXfermode::kColorDodge_Mode,   "ColorDodge"  },
-            { SkXfermode::kColorBurn_Mode,    "ColorBurn"   },
-            { SkXfermode::kHardLight_Mode,    "HardLight"   },
-            { SkXfermode::kSoftLight_Mode,    "SoftLight"   },
-            { SkXfermode::kDifference_Mode,   "Difference"  },
-            { SkXfermode::kExclusion_Mode,    "Exclusion"   },
-            { SkXfermode::kMultiply_Mode,     "Multiply"    },
-            { SkXfermode::kHue_Mode,          "Hue"         },
-            { SkXfermode::kSaturation_Mode,   "Saturation"  },
-            { 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,     "Modulate"    },
+            { SkBlendMode::kScreen,       "Screen"      },
+            { SkBlendMode::kOverlay,      "Overlay"     },
+            { SkBlendMode::kDarken,       "Darken"      },
+            { SkBlendMode::kLighten,      "Lighten"     },
+            { SkBlendMode::kColorDodge,   "ColorDodge"  },
+            { SkBlendMode::kColorBurn,    "ColorBurn"   },
+            { SkBlendMode::kHardLight,    "HardLight"   },
+            { SkBlendMode::kSoftLight,    "SoftLight"   },
+            { SkBlendMode::kDifference,   "Difference"  },
+            { SkBlendMode::kExclusion,    "Exclusion"   },
+            { SkBlendMode::kMultiply,     "Multiply"    },
+            { SkBlendMode::kHue,          "Hue"         },
+            { SkBlendMode::kSaturation,   "Saturation"  },
+            { SkBlendMode::kColor,        "Color"       },
+            { SkBlendMode::kLuminosity,   "Luminosity"  },
         };
 
         const SkScalar w = SkIntToScalar(W);
@@ -128,7 +128,7 @@ protected:
             p.setShader(nullptr);
             canvas->drawRect(r, p);
 
-            textP.setXfermode(SkXfermode::Make(gModes[i].fMode));
+            textP.setBlendMode(gModes[i].fMode);
             canvas->drawText("H", 1, x+ w/10.f, y + 7.f*h/8.f, textP);
 #if 1
             canvas->drawText(gModes[i].fLabel, strlen(gModes[i].fLabel),
diff --git a/gm/drawatlas.cpp b/gm/drawatlas.cpp
index dd81628378..43b103c2c3 100644
--- a/gm/drawatlas.cpp
+++ b/gm/drawatlas.cpp
@@ -23,12 +23,12 @@ class DrawAtlasGM : public skiagm::GM {
         canvas->clear(SK_ColorRED);
 
         SkPaint paint;
-        paint.setXfermodeMode(SkXfermode::kClear_Mode);
+        paint.setBlendMode(SkBlendMode::kClear);
         SkRect r(target);
         r.inset(-1, -1);
         // zero out a place (with a 1-pixel border) to land our drawing.
         canvas->drawRect(r, paint);
-        paint.setXfermode(nullptr);
+        paint.setBlendMode(SkBlendMode::kSrcOver);
         paint.setColor(SK_ColorBLUE);
         paint.setAntiAlias(true);
         canvas->drawOval(target, paint);
diff --git a/gm/drawatlascolor.cpp b/gm/drawatlascolor.cpp
index d7b973c3fd..bf76c48e5f 100644
--- a/gm/drawatlascolor.cpp
+++ b/gm/drawatlascolor.cpp
@@ -26,7 +26,7 @@ static sk_sp<SkImage> make_atlas(SkCanvas* caller, int atlasSize) {
     SkCanvas* canvas = surface->getCanvas();
 
     SkPaint paint;
-    paint.setXfermode(SkXfermode::Make(SkXfermode::kSrc_Mode));
+    paint.setBlendMode(SkBlendMode::kSrc);
 
     paint.setColor(SK_ColorWHITE);
     SkRect r = SkRect::MakeXYWH(0, 0,
diff --git a/gm/dstreadshuffle.cpp b/gm/dstreadshuffle.cpp
index 47c70563b5..72a68b1d9d 100644
--- a/gm/dstreadshuffle.cpp
+++ b/gm/dstreadshuffle.cpp
@@ -159,8 +159,8 @@ protected:
                             p.setColor(color);
                             // In order to get some batching on the GPU backend we do 2 src over for
                             // each xfer mode which requires a dst read
-                            p.setXfermodeMode(r % 3 == 0 ? SkXfermode::kLighten_Mode :
-                                                           SkXfermode::kSrcOver_Mode);
+                            p.setBlendMode(r % 3 == 0 ? SkBlendMode::kLighten :
+                                                        SkBlendMode::kSrcOver);
                             SetStyle(&p, style, width);
                             canvas->save();
                             canvas->translate(x, y);
diff --git a/gm/gamma.cpp b/gm/gamma.cpp
index f6b4a9ceed..80209e53f8 100644
--- a/gm/gamma.cpp
+++ b/gm/gamma.cpp
@@ -75,11 +75,11 @@ DEF_SIMPLE_GM(gamma, canvas, 850, 200) {
         advance();
     };
 
-    auto nextXferRect = [&](SkColor srcColor, SkXfermode::Mode mode, SkColor dstColor) {
+    auto nextXferRect = [&](SkColor srcColor, SkBlendMode mode, SkColor dstColor) {
         p.setColor(dstColor);
         canvas->drawRect(r, p);
         p.setColor(srcColor);
-        p.setXfermodeMode(mode);
+        p.setBlendMode(mode);
         canvas->drawRect(r, p);
 
         SkString srcText = SkStringPrintf("%08X", srcColor);
@@ -207,18 +207,18 @@ DEF_SIMPLE_GM(gamma, canvas, 850, 200) {
 
     canvas->saveLayer(nullptr, nullptr);
 
-    nextXferRect(0x7fffffff, SkXfermode::kSrcOver_Mode, SK_ColorBLACK);
-    nextXferRect(0x7f000000, SkXfermode::kSrcOver_Mode, SK_ColorWHITE);
+    nextXferRect(0x7fffffff, SkBlendMode::kSrcOver, SK_ColorBLACK);
+    nextXferRect(0x7f000000, SkBlendMode::kSrcOver, SK_ColorWHITE);
 
-    nextXferRect(SK_ColorBLACK, SkXfermode::kDstOver_Mode, 0x7fffffff);
-    nextXferRect(SK_ColorWHITE, SkXfermode::kSrcIn_Mode, 0x7fff00ff);
-    nextXferRect(0x7fff00ff, SkXfermode::kDstIn_Mode, SK_ColorWHITE);
+    nextXferRect(SK_ColorBLACK, SkBlendMode::kDstOver, 0x7fffffff);
+    nextXferRect(SK_ColorWHITE, SkBlendMode::kSrcIn, 0x7fff00ff);
+    nextXferRect(0x7fff00ff, SkBlendMode::kDstIn, SK_ColorWHITE);
 
     // 0x89 = 255 * linear_to_srgb(0.25)
-    nextXferRect(0xff898989, SkXfermode::kPlus_Mode, 0xff898989);
+    nextXferRect(0xff898989, SkBlendMode::kPlus, 0xff898989);
 
     // 0xDB = 255 * linear_to_srgb(sqrt(0.5))
-    nextXferRect(0xffdbdbdb, SkXfermode::kModulate_Mode, 0xffdbdbdb);
+    nextXferRect(0xffdbdbdb, SkBlendMode::kModulate, 0xffdbdbdb);
 
     canvas->restore();
 }
diff --git a/gm/gm.cpp b/gm/gm.cpp
index b6cac0ce1f..1b0598ff77 100644
--- a/gm/gm.cpp
+++ b/gm/gm.cpp
@@ -58,7 +58,7 @@ bool GM::animate(const SkAnimTimer& timer) {
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 void GM::onDrawBackground(SkCanvas* canvas) {
-    canvas->drawColor(fBGColor, SkXfermode::kSrc_Mode);
+    canvas->drawColor(fBGColor, SkBlendMode::kSrc);
 }
 
 void GM::drawSizeBounds(SkCanvas* canvas, SkColor color) {
diff --git a/gm/hairmodes.cpp b/gm/hairmodes.cpp
index de937c439b..a628f4aafe 100644
--- a/gm/hairmodes.cpp
+++ b/gm/hairmodes.cpp
@@ -11,21 +11,21 @@
 #include "SkShader.h"
 
 constexpr 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"       },
+    { 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"       },
 };
 
 const int gWidth = 64;
@@ -33,7 +33,7 @@ const int gHeight = 64;
 const SkScalar W = SkIntToScalar(gWidth);
 const SkScalar H = SkIntToScalar(gHeight);
 
-static SkScalar drawCell(SkCanvas* canvas, sk_sp<SkXfermode> mode, SkAlpha a0, SkAlpha a1) {
+static SkScalar drawCell(SkCanvas* canvas, SkBlendMode mode, SkAlpha a0, SkAlpha a1) {
 
     SkPaint paint;
     paint.setAntiAlias(true);
@@ -47,7 +47,7 @@ static SkScalar drawCell(SkCanvas* canvas, sk_sp<SkXfermode> mode, SkAlpha a0, S
 
     paint.setColor(SK_ColorRED);
     paint.setAlpha(a1);
-    paint.setXfermode(std::move(mode));
+    paint.setBlendMode(mode);
     for (int angle = 0; angle < 24; ++angle) {
         SkScalar x = SkScalarCos(SkIntToScalar(angle) * (SK_ScalarPI * 2) / 24) * gWidth;
         SkScalar y = SkScalarSin(SkIntToScalar(angle) * (SK_ScalarPI * 2) / 24) * gHeight;
@@ -104,7 +104,7 @@ namespace skiagm {
 
                     canvas->drawRect(bounds, fBGPaint);
                     canvas->saveLayer(&bounds, nullptr);
-                    SkScalar dy = drawCell(canvas, SkXfermode::Make(gModes[i].fMode),
+                    SkScalar dy = drawCell(canvas, gModes[i].fMode,
                                            gAlphaValue[alpha & 1],
                                            gAlphaValue[alpha & 2]);
                     canvas->restore();
diff --git a/gm/imagefilters.cpp b/gm/imagefilters.cpp
index e9f54a312d..27422b5611 100644
--- a/gm/imagefilters.cpp
+++ b/gm/imagefilters.cpp
@@ -19,7 +19,7 @@
  *
  *  see https://bug.skia.org/3741
  */
-static void do_draw(SkCanvas* canvas, SkXfermode::Mode mode, sk_sp<SkImageFilter> imf) {
+static void do_draw(SkCanvas* canvas, SkBlendMode mode, sk_sp<SkImageFilter> imf) {
         SkAutoCanvasRestore acr(canvas, true);
         canvas->clipRect(SkRect::MakeWH(220, 220));
 
@@ -40,7 +40,7 @@ static void do_draw(SkCanvas* canvas, SkXfermode::Mode mode, sk_sp<SkImageFilter
 
         paint.setColor(0x660000FF);
         paint.setImageFilter(std::move(imf));
-        paint.setXfermodeMode(mode);
+        paint.setBlendMode(mode);
         canvas->drawOval(r1, paint);
 }
 
@@ -52,8 +52,8 @@ DEF_SIMPLE_GM(imagefilters_xfermodes, canvas, 480, 480) {
                                                                  kNone_SkFilterQuality,
                                                                  nullptr));
 
-        const SkXfermode::Mode modes[] = {
-            SkXfermode::kSrcATop_Mode, SkXfermode::kDstIn_Mode
+        const SkBlendMode modes[] = {
+            SkBlendMode::kSrcATop, SkBlendMode::kDstIn
         };
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(modes); ++i) {
diff --git a/gm/imagefiltersgraph.cpp b/gm/imagefiltersgraph.cpp
index 980398967a..2d27728710 100644
--- a/gm/imagefiltersgraph.cpp
+++ b/gm/imagefiltersgraph.cpp
@@ -69,9 +69,8 @@ protected:
             sk_sp<SkImageFilter> colorMorph(SkColorFilterImageFilter::Make(std::move(matrixFilter),
                                                                            std::move(morph)));
             SkPaint paint;
-            paint.setImageFilter(SkXfermodeImageFilter::Make(
-                                        SkXfermode::Make(SkXfermode::kSrcOver_Mode),
-                                        std::move(colorMorph)));
+            paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
+                                                             std::move(colorMorph)));
 
             DrawClippedImage(canvas, fImage.get(), paint);
             canvas->translate(SkIntToScalar(100), 0);
@@ -105,9 +104,8 @@ protected:
             SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
             SkPaint paint;
             paint.setImageFilter(
-                SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kSrcIn_Mode),
-                                            std::move(blur),
-                                            nullptr, &cropRect));
+                SkXfermodeImageFilter::Make(SkBlendMode::kSrcIn, std::move(blur), nullptr,
+                                            &cropRect));
             DrawClippedImage(canvas, fImage.get(), paint);
             canvas->translate(SkIntToScalar(100), 0);
         }
diff --git a/gm/imagefilterstransformed.cpp b/gm/imagefilterstransformed.cpp
index 0906eb3f3c..dc8257ce1d 100644
--- a/gm/imagefilterstransformed.cpp
+++ b/gm/imagefilterstransformed.cpp
@@ -127,7 +127,7 @@ DEF_SIMPLE_GM(rotate_imagefilter, canvas, 500, 500) {
     sk_sp<SkImageFilter> filters[] = {
         nullptr,
         SkBlurImageFilter::Make(6, 0, nullptr),
-        SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kSrcOver_Mode), nullptr),
+        SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver, nullptr),
     };
 
     for (auto& filter : filters) {
diff --git a/gm/lcdblendmodes.cpp b/gm/lcdblendmodes.cpp
index 537c4cbda3..a16e219c6b 100644
--- a/gm/lcdblendmodes.cpp
+++ b/gm/lcdblendmodes.cpp
@@ -76,44 +76,44 @@ protected:
         this->drawColumn(surfCanvas, SK_ColorCYAN, SK_ColorMAGENTA, true);
 
         SkPaint surfPaint;
-        surfPaint.setXfermode(SkXfermode::Make(SkXfermode::kSrcOver_Mode));
+        surfPaint.setBlendMode(SkBlendMode::kSrcOver);
         surface->draw(canvas, 0, 0, &surfPaint);
     }
 
     void drawColumn(SkCanvas* canvas, SkColor backgroundColor, SkColor textColor, bool useGrad) {
         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,     "Modulate"    },
-            { SkXfermode::kScreen_Mode,       "Screen"      },
-            { SkXfermode::kOverlay_Mode,      "Overlay"     },
-            { SkXfermode::kDarken_Mode,       "Darken"      },
-            { SkXfermode::kLighten_Mode,      "Lighten"     },
-            { SkXfermode::kColorDodge_Mode,   "ColorDodge"  },
-            { SkXfermode::kColorBurn_Mode,    "ColorBurn"   },
-            { SkXfermode::kHardLight_Mode,    "HardLight"   },
-            { SkXfermode::kSoftLight_Mode,    "SoftLight"   },
-            { SkXfermode::kDifference_Mode,   "Difference"  },
-            { SkXfermode::kExclusion_Mode,    "Exclusion"   },
-            { SkXfermode::kMultiply_Mode,     "Multiply"    },
-            { SkXfermode::kHue_Mode,          "Hue"         },
-            { SkXfermode::kSaturation_Mode,   "Saturation"  },
-            { 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,     "Modulate"    },
+            { SkBlendMode::kScreen,       "Screen"      },
+            { SkBlendMode::kOverlay,      "Overlay"     },
+            { SkBlendMode::kDarken,       "Darken"      },
+            { SkBlendMode::kLighten,      "Lighten"     },
+            { SkBlendMode::kColorDodge,   "ColorDodge"  },
+            { SkBlendMode::kColorBurn,    "ColorBurn"   },
+            { SkBlendMode::kHardLight,    "HardLight"   },
+            { SkBlendMode::kSoftLight,    "SoftLight"   },
+            { SkBlendMode::kDifference,   "Difference"  },
+            { SkBlendMode::kExclusion,    "Exclusion"   },
+            { SkBlendMode::kMultiply,     "Multiply"    },
+            { SkBlendMode::kHue,          "Hue"         },
+            { SkBlendMode::kSaturation,   "Saturation"  },
+            { SkBlendMode::kColor,        "Color"       },
+            { SkBlendMode::kLuminosity,   "Luminosity"  },
         };
         // Draw background rect
         SkPaint backgroundPaint;
@@ -128,7 +128,7 @@ protected:
             paint.setSubpixelText(true);
             paint.setLCDRenderText(true);
             paint.setTextSize(fTextHeight);
-            paint.setXfermode(SkXfermode::Make(gModes[m].fMode));
+            paint.setBlendMode(gModes[m].fMode);
             sk_tool_utils::set_portable_typeface(&paint);
             if (useGrad) {
                 SkRect r;
diff --git a/gm/lcdoverlap.cpp b/gm/lcdoverlap.cpp
index 623d74622d..380878539f 100644
--- a/gm/lcdoverlap.cpp
+++ b/gm/lcdoverlap.cpp
@@ -49,8 +49,8 @@ protected:
 
     SkISize onISize() override { return SkISize::Make(kWidth, kHeight); }
 
-    void drawTestCase(SkCanvas* canvas, SkScalar x, SkScalar y, SkXfermode::Mode mode,
-                      SkXfermode::Mode mode2) {
+    void drawTestCase(SkCanvas* canvas, SkScalar x, SkScalar y, SkBlendMode mode,
+                      SkBlendMode mode2) {
         const SkColor colors[] {
                 SK_ColorRED,
                 SK_ColorGREEN,
@@ -60,8 +60,6 @@ protected:
                 SK_ColorMAGENTA,
         };
 
-        sk_sp<SkXfermode> xfermode(SkXfermode::Make(mode));
-        sk_sp<SkXfermode> xfermode2(SkXfermode::Make(mode2));
         for (size_t i = 0; i < SK_ARRAY_COUNT(colors); i++) {
             canvas->save();
             canvas->translate(x, y);
@@ -70,7 +68,7 @@ protected:
 
             SkPaint textPaint;
             textPaint.setColor(colors[i]);
-            textPaint.setXfermode(i % 2 == 0 ? xfermode : xfermode2);
+            textPaint.setBlendMode(i % 2 == 0 ? mode : mode2);
             canvas->drawTextBlob(fBlob, 0, 0, textPaint);
             canvas->restore();
         }
@@ -79,13 +77,11 @@ protected:
     void onDraw(SkCanvas* canvas) override {
         SkScalar offsetX = kWidth / 4.0f;
         SkScalar offsetY = kHeight / 4.0f;
-        drawTestCase(canvas, offsetX, offsetY,  SkXfermode::kSrc_Mode, SkXfermode::kSrc_Mode);
-        drawTestCase(canvas, 3 * offsetX, offsetY,  SkXfermode::kSrcOver_Mode,
-                     SkXfermode::kSrcOver_Mode);
-        drawTestCase(canvas, offsetX, 3 * offsetY,  SkXfermode::kHardLight_Mode,
-                     SkXfermode::kLuminosity_Mode);
-        drawTestCase(canvas, 3 * offsetX, 3 * offsetY,  SkXfermode::kSrcOver_Mode,
-                     SkXfermode::kSrc_Mode);
+        drawTestCase(canvas, offsetX, offsetY,  SkBlendMode::kSrc, SkBlendMode::kSrc);
+        drawTestCase(canvas, 3 * offsetX, offsetY,  SkBlendMode::kSrcOver, SkBlendMode::kSrcOver);
+        drawTestCase(canvas, offsetX, 3 * offsetY,  SkBlendMode::kHardLight,
+                     SkBlendMode::kLuminosity);
+        drawTestCase(canvas, 3 * offsetX, 3 * offsetY,  SkBlendMode::kSrcOver, SkBlendMode::kSrc);
     }
 
 private:
diff --git a/gm/lumafilter.cpp b/gm/lumafilter.cpp
index 10eefabd56..3852d9385f 100644
--- a/gm/lumafilter.cpp
+++ b/gm/lumafilter.cpp
@@ -26,7 +26,7 @@ static void draw_label(SkCanvas* canvas, const char* label,
                      paint);
 }
 
-static void draw_scene(SkCanvas* canvas, const sk_sp<SkColorFilter>& filter, SkXfermode::Mode mode,
+static void draw_scene(SkCanvas* canvas, const sk_sp<SkColorFilter>& filter, SkBlendMode mode,
                        const sk_sp<SkShader>& s1, const sk_sp<SkShader>& s2) {
     SkPaint paint;
     paint.setAntiAlias(true);
@@ -53,7 +53,7 @@ static void draw_scene(SkCanvas* canvas, const sk_sp<SkColorFilter>& filter, SkX
     }
 
     SkPaint xferPaint;
-    xferPaint.setXfermodeMode(mode);
+    xferPaint.setBlendMode(mode);
     canvas->saveLayer(&bounds, &xferPaint);
 
     r = bounds;
@@ -101,13 +101,14 @@ protected:
     }
 
     void onDraw(SkCanvas* canvas) override {
-        SkXfermode::Mode modes[] = { SkXfermode::kSrcOver_Mode,
-                                     SkXfermode::kDstOver_Mode,
-                                     SkXfermode::kSrcATop_Mode,
-                                     SkXfermode::kDstATop_Mode,
-                                     SkXfermode::kSrcIn_Mode,
-                                     SkXfermode::kDstIn_Mode,
-                                   };
+        SkBlendMode modes[] = {
+            SkBlendMode::kSrcOver,
+            SkBlendMode::kDstOver,
+            SkBlendMode::kSrcATop,
+            SkBlendMode::kDstATop,
+            SkBlendMode::kSrcIn,
+            SkBlendMode::kDstIn,
+        };
         struct {
             const sk_sp<SkShader>& fShader1;
             const sk_sp<SkShader>& fShader2;
diff --git a/gm/modecolorfilters.cpp b/gm/modecolorfilters.cpp
index 50bb27f9d8..ae926ef1fe 100644
--- a/gm/modecolorfilters.cpp
+++ b/gm/modecolorfilters.cpp
@@ -78,7 +78,7 @@ protected:
         }
         SkPaint bgPaint;
         bgPaint.setShader(fBmpShader);
-        bgPaint.setXfermodeMode(SkXfermode::kSrc_Mode);
+        bgPaint.setBlendMode(SkBlendMode::kSrc);
 
         sk_sp<SkShader> shaders[] = {
             nullptr,                                   // use a paint color instead of a shader
diff --git a/gm/picture.cpp b/gm/picture.cpp
index 1ea8adaa76..72d4159aa9 100644
--- a/gm/picture.cpp
+++ b/gm/picture.cpp
@@ -29,7 +29,7 @@ static sk_sp<SkPicture> make_picture() {
     canvas->drawPath(path, paint);
 
     paint.setColor(0x80FFFFFF);
-    paint.setXfermodeMode(SkXfermode::kPlus_Mode);
+    paint.setBlendMode(SkBlendMode::kPlus);
     canvas->drawRect(SkRect::MakeXYWH(25, 25, 50, 50), paint);
 
     return rec.finishRecordingAsPicture();
diff --git a/gm/plus.cpp b/gm/plus.cpp
index 6a5af61d80..51ac2cb103 100644
--- a/gm/plus.cpp
+++ b/gm/plus.cpp
@@ -37,7 +37,7 @@ DEF_SIMPLE_GM(PlusMergesAA, canvas, 256, 256) {
 
     // Using Plus on the right should merge the AA of seam together completely covering the red.
     canvas->saveLayer(nullptr, nullptr);
-      p.setXfermodeMode(SkXfermode::kPlus_Mode);
+      p.setBlendMode(SkBlendMode::kPlus);
       canvas->translate(150, 0);
       canvas->drawPath(upperLeft, p);
       canvas->drawPath(bottomRight, p);
diff --git a/gm/srcmode.cpp b/gm/srcmode.cpp
index 0d02cdceb0..d57b77cbd9 100644
--- a/gm/srcmode.cpp
+++ b/gm/srcmode.cpp
@@ -82,8 +82,8 @@ protected:
             draw_hair, draw_thick, draw_rect, draw_oval, draw_text
         };
 
-        const SkXfermode::Mode modes[] = {
-            SkXfermode::kSrcOver_Mode, SkXfermode::kSrc_Mode, SkXfermode::kClear_Mode
+        const SkBlendMode modes[] = {
+            SkBlendMode::kSrcOver, SkBlendMode::kSrc, SkBlendMode::kClear
         };
 
         const PaintProc paintProcs[] = {
@@ -96,7 +96,7 @@ protected:
             for (size_t i = 0; i < SK_ARRAY_COUNT(paintProcs); ++i) {
                 paintProcs[i](&paint);
                 for (size_t x = 0; x < SK_ARRAY_COUNT(modes); ++x) {
-                    paint.setXfermodeMode(modes[x]);
+                    paint.setBlendMode(modes[x]);
                     canvas->save();
                     for (size_t y = 0; y < SK_ARRAY_COUNT(procs); ++y) {
                         procs[y](canvas, paint);
diff --git a/gm/textblobblockreordering.cpp b/gm/textblobblockreordering.cpp
index 3974aca5ab..c581e135a6 100644
--- a/gm/textblobblockreordering.cpp
+++ b/gm/textblobblockreordering.cpp
@@ -69,7 +69,7 @@ protected:
         redPaint.setColor(SK_ColorRED);
         canvas->drawRect(bounds, redPaint);
         SkPaint srcInPaint(paint);
-        srcInPaint.setXfermodeMode(SkXfermode::kSrcIn_Mode);
+        srcInPaint.setBlendMode(SkBlendMode::kSrcIn);
         canvas->drawTextBlob(fBlob, 0, 0, srcInPaint);
 
         canvas->translate(SkIntToScalar(xDelta), SkIntToScalar(yDelta));
diff --git a/gm/textbloblooper.cpp b/gm/textbloblooper.cpp
index 3adf34909c..37eae66606 100644
--- a/gm/textbloblooper.cpp
+++ b/gm/textbloblooper.cpp
@@ -51,7 +51,7 @@ static void add_to_text_blob(SkTextBlobBuilder* builder, const char* text, const
 typedef void (*LooperProc)(SkPaint*);
 
 struct LooperSettings {
-    SkXfermode::Mode fMode;
+    SkBlendMode      fMode;
     SkColor          fColor;
     SkPaint::Style   fStyle;
     SkScalar         fWidth;
@@ -120,7 +120,7 @@ static sk_sp<SkDrawLooper> setupLooper(SkLayerDrawLooper::BitFlags bits,
     for (size_t i = 0; i < size; i++) {
         info.fOffset.set(settings[i].fOffset, settings[i].fOffset);
         SkPaint* paint = looperBuilder.addLayer(info);
-        paint->setXfermodeMode(settings[i].fMode);
+        paint->setBlendMode(settings[i].fMode);
         paint->setColor(settings[i].fColor);
         paint->setStyle(settings[i].fStyle);
         paint->setStrokeWidth(settings[i].fWidth);
@@ -152,37 +152,37 @@ protected:
 
         // create a looper which sandwhiches an effect in two normal draws
         LooperSettings looperSandwhich[] = {
-           { SkXfermode::kSrc_Mode, SK_ColorMAGENTA, SkPaint::kFill_Style, 0, 0, 0, false },
-           { SkXfermode::kSrcOver_Mode, 0x88000000, SkPaint::kFill_Style, 0, 10.f, 0, true },
-           { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
+           { SkBlendMode::kSrc, SK_ColorMAGENTA, SkPaint::kFill_Style, 0, 0, 0, false },
+           { SkBlendMode::kSrcOver, 0x88000000, SkPaint::kFill_Style, 0, 10.f, 0, true },
+           { SkBlendMode::kSrcOver, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
         };
 
         LooperSettings compound[] = {
-            { SkXfermode::kSrc_Mode, SK_ColorWHITE, SkPaint::kStroke_Style, 1.f * 3/4, 0, 0, false },
-            { SkXfermode::kSrc_Mode, SK_ColorRED, SkPaint::kStroke_Style, 4.f, 0, 0, false },
-            { SkXfermode::kSrc_Mode, SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0, false },
-            { SkXfermode::kSrcOver_Mode, 0x88000000, SkPaint::kFill_Style, 0, 10.f, 0, true }
+            { SkBlendMode::kSrc, SK_ColorWHITE, SkPaint::kStroke_Style, 1.f * 3/4, 0, 0, false },
+            { SkBlendMode::kSrc, SK_ColorRED, SkPaint::kStroke_Style, 4.f, 0, 0, false },
+            { SkBlendMode::kSrc, SK_ColorBLUE, SkPaint::kFill_Style, 0, 0, 0, false },
+            { SkBlendMode::kSrcOver, 0x88000000, SkPaint::kFill_Style, 0, 10.f, 0, true }
         };
 
         LooperSettings xfermode[] = {
-            { SkXfermode::kDifference_Mode, SK_ColorWHITE, SkPaint::kFill_Style, 0, 0, 0, false },
-            { SkXfermode::kSrcOver_Mode, 0xFF000000, SkPaint::kFill_Style, 0, 1.f, 0, true },
-            { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 2.f, 0, false },
+            { SkBlendMode::kDifference, SK_ColorWHITE, SkPaint::kFill_Style, 0, 0, 0, false },
+            { SkBlendMode::kSrcOver, 0xFF000000, SkPaint::kFill_Style, 0, 1.f, 0, true },
+            { SkBlendMode::kSrcOver, 0x50FF00FF, SkPaint::kFill_Style, 0, 2.f, 0, false },
         };
 
         // NOTE, this should be ignored by textblobs
         LooperSettings skew[] = {
-            { SkXfermode::kSrc_Mode, SK_ColorRED, SkPaint::kFill_Style, 0, 0, -1.f, false },
-            { SkXfermode::kSrc_Mode, SK_ColorGREEN, SkPaint::kFill_Style, 0, 10.f, -1.f, false },
-            { SkXfermode::kSrc_Mode, SK_ColorBLUE, SkPaint::kFill_Style, 0, 20.f, -1.f, false },
+            { SkBlendMode::kSrc, SK_ColorRED, SkPaint::kFill_Style, 0, 0, -1.f, false },
+            { SkBlendMode::kSrc, SK_ColorGREEN, SkPaint::kFill_Style, 0, 10.f, -1.f, false },
+            { SkBlendMode::kSrc, SK_ColorBLUE, SkPaint::kFill_Style, 0, 20.f, -1.f, false },
         };
 
         LooperSettings kitchenSink[] = {
-            { SkXfermode::kSrc_Mode, SK_ColorWHITE, SkPaint::kStroke_Style, 1.f * 3/4, 0, 0, false },
-            { SkXfermode::kSrc_Mode, SK_ColorBLACK, SkPaint::kFill_Style, 0, 0, 0, false },
-            { SkXfermode::kDifference_Mode, SK_ColorWHITE, SkPaint::kFill_Style, 1.f, 10.f, 0, false },
-            { SkXfermode::kSrc_Mode, SK_ColorWHITE, SkPaint::kFill_Style, 0, 10.f, 0, true },
-            { SkXfermode::kSrcOver_Mode, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
+            { SkBlendMode::kSrc, SK_ColorWHITE, SkPaint::kStroke_Style, 1.f * 3/4, 0, 0, false },
+            { SkBlendMode::kSrc, SK_ColorBLACK, SkPaint::kFill_Style, 0, 0, 0, false },
+            { SkBlendMode::kDifference, SK_ColorWHITE, SkPaint::kFill_Style, 1.f, 10.f, 0, false },
+            { SkBlendMode::kSrc, SK_ColorWHITE, SkPaint::kFill_Style, 0, 10.f, 0, true },
+            { SkBlendMode::kSrcOver, 0x50FF00FF, SkPaint::kFill_Style, 0, 20.f, 0, false },
         };
 
         fLoopers.push_back(setupLooper(SkLayerDrawLooper::kMaskFilter_Bit |
diff --git a/gm/texteffects.cpp b/gm/texteffects.cpp
index 6a5a9c1fb0..453a555a6f 100644
--- a/gm/texteffects.cpp
+++ b/gm/texteffects.cpp
@@ -25,7 +25,7 @@ static void r0(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
 
     p.setAlpha(0x11);
     p.setStyle(SkPaint::kFill_Style);
-    p.setXfermodeMode(SkXfermode::kSrc_Mode);
+    p.setBlendMode(SkBlendMode::kSrc);
     rastBuilder->addLayer(p);
 }
 
@@ -33,7 +33,7 @@ static void r1(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     rastBuilder->addLayer(p);
 
     p.setAlpha(0x40);
-    p.setXfermodeMode(SkXfermode::kSrc_Mode);
+    p.setBlendMode(SkBlendMode::kSrc);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1*2);
     rastBuilder->addLayer(p);
@@ -46,7 +46,7 @@ static void r2(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
 
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1*3/2);
-    p.setXfermodeMode(SkXfermode::kClear_Mode);
+    p.setBlendMode(SkBlendMode::kClear);
     rastBuilder->addLayer(p);
 }
 
@@ -57,7 +57,7 @@ static void r3(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
 
     p.setAlpha(0x20);
     p.setStyle(SkPaint::kFill_Style);
-    p.setXfermodeMode(SkXfermode::kSrc_Mode);
+    p.setBlendMode(SkBlendMode::kSrc);
     rastBuilder->addLayer(p);
 }
 
@@ -66,10 +66,10 @@ static void r4(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     rastBuilder->addLayer(p, SkIntToScalar(3), SkIntToScalar(3));
 
     p.setAlpha(0xFF);
-    p.setXfermodeMode(SkXfermode::kClear_Mode);
+    p.setBlendMode(SkBlendMode::kClear);
     rastBuilder->addLayer(p, SK_Scalar1*3/2, SK_Scalar1*3/2);
 
-    p.setXfermode(nullptr);
+    p.setBlendMode(SkBlendMode::kSrcOver);
     rastBuilder->addLayer(p);
 }
 
@@ -79,7 +79,7 @@ static void r5(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     rastBuilder->addLayer(p);
 
     p.setPathEffect(SkDiscretePathEffect::Make(SK_Scalar1*4, SK_Scalar1*3));
-    p.setXfermodeMode(SkXfermode::kSrcOut_Mode);
+    p.setBlendMode(SkBlendMode::kSrcOut);
     rastBuilder->addLayer(p);
 }
 
@@ -90,7 +90,7 @@ static void r6(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     SkLayerRasterizer::Builder rastBuilder2;
     r5(&rastBuilder2, p);
     p.setRasterizer(rastBuilder2.detach());
-    p.setXfermodeMode(SkXfermode::kClear_Mode);
+    p.setBlendMode(SkBlendMode::kClear);
     rastBuilder->addLayer(p);
 }
 
@@ -117,11 +117,11 @@ static void r8(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     lattice.setScale(SK_Scalar1*6, SK_Scalar1*6, 0, 0);
     lattice.postSkew(SK_Scalar1/3, 0, 0, 0);
     p.setPathEffect(MakeDotEffect(SK_Scalar1*2, lattice));
-    p.setXfermodeMode(SkXfermode::kClear_Mode);
+    p.setBlendMode(SkBlendMode::kClear);
     rastBuilder->addLayer(p);
 
     p.setPathEffect(nullptr);
-    p.setXfermode(nullptr);
+    p.setBlendMode(SkBlendMode::kSrcOver);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1);
     rastBuilder->addLayer(p);
@@ -134,11 +134,11 @@ static void r9(SkLayerRasterizer::Builder* rastBuilder, SkPaint& p) {
     lattice.setScale(SK_Scalar1, SK_Scalar1*6, 0, 0);
     lattice.postRotate(SkIntToScalar(30), 0, 0);
     p.setPathEffect(SkLine2DPathEffect::Make(SK_Scalar1*2, lattice));
-    p.setXfermodeMode(SkXfermode::kClear_Mode);
+    p.setBlendMode(SkBlendMode::kClear);
     rastBuilder->addLayer(p);
 
     p.setPathEffect(nullptr);
-    p.setXfermode(nullptr);
+    p.setBlendMode(SkBlendMode::kSrcOver);
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SK_Scalar1);
     rastBuilder->addLayer(p);
diff --git a/gm/texturedomaineffect.cpp b/gm/texturedomaineffect.cpp
index 2dd340e425..b0d2ecede6 100644
--- a/gm/texturedomaineffect.cpp
+++ b/gm/texturedomaineffect.cpp
@@ -57,14 +57,14 @@ protected:
         SkColor colors2[] = { SK_ColorMAGENTA, SK_ColorLTGRAY, SK_ColorYELLOW };
         paint.setShader(SkGradientShader::MakeSweep(45.f, 55.f, colors2, nullptr,
                                                     SK_ARRAY_COUNT(colors2)));
-        paint.setXfermodeMode(SkXfermode::kDarken_Mode);
+        paint.setBlendMode(SkBlendMode::kDarken);
         canvas.drawOval(SkRect::MakeXYWH(-5.f, -5.f, fBmp.width() + 10.f, fBmp.height() + 10.f),
                         paint);
 
         SkColor colors3[] = { SK_ColorBLUE, SK_ColorLTGRAY, SK_ColorGREEN };
         paint.setShader(SkGradientShader::MakeSweep(25.f, 35.f, colors3, nullptr,
                                                     SK_ARRAY_COUNT(colors3)));
-        paint.setXfermodeMode(SkXfermode::kLighten_Mode);
+        paint.setBlendMode(SkBlendMode::kLighten);
         canvas.drawOval(SkRect::MakeXYWH(-5.f, -5.f, fBmp.width() + 10.f, fBmp.height() + 10.f),
                         paint);
     }
diff --git a/gm/verylargebitmap.cpp b/gm/verylargebitmap.cpp
index f257bf973a..9f1c05f9b3 100644
--- a/gm/verylargebitmap.cpp
+++ b/gm/verylargebitmap.cpp
@@ -18,7 +18,7 @@ static void draw(SkCanvas* canvas, int width, int height, SkColor colors[2]) {
     SkPaint paint;
     paint.setShader(SkGradientShader::MakeRadial(center, radius, colors, nullptr, 2,
                                                  SkShader::kMirror_TileMode));
-    paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+    paint.setBlendMode(SkBlendMode::kSrc);
     canvas->drawPaint(paint);
 }
 
diff --git a/gm/xfermodeimagefilter.cpp b/gm/xfermodeimagefilter.cpp
index a0677c796a..91908599ff 100644
--- a/gm/xfermodeimagefilter.cpp
+++ b/gm/xfermodeimagefilter.cpp
@@ -48,46 +48,45 @@ protected:
         SkPaint paint;
 
         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,     "Modulate"      },
-            { SkXfermode::kScreen_Mode,       "Screen"        },
-            { SkXfermode::kOverlay_Mode,      "Overlay"       },
-            { SkXfermode::kDarken_Mode,       "Darken"        },
-            { SkXfermode::kLighten_Mode,      "Lighten"       },
-            { SkXfermode::kColorDodge_Mode,   "ColorDodge"    },
-            { SkXfermode::kColorBurn_Mode,    "ColorBurn"     },
-            { SkXfermode::kHardLight_Mode,    "HardLight"     },
-            { SkXfermode::kSoftLight_Mode,    "SoftLight"     },
-            { SkXfermode::kDifference_Mode,   "Difference"    },
-            { SkXfermode::kExclusion_Mode,    "Exclusion"     },
-            { SkXfermode::kMultiply_Mode,     "Multiply"      },
-            { SkXfermode::kHue_Mode,          "Hue"           },
-            { SkXfermode::kSaturation_Mode,   "Saturation"    },
-            { 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,     "Modulate"      },
+            { SkBlendMode::kScreen,       "Screen"        },
+            { SkBlendMode::kOverlay,      "Overlay"       },
+            { SkBlendMode::kDarken,       "Darken"        },
+            { SkBlendMode::kLighten,      "Lighten"       },
+            { SkBlendMode::kColorDodge,   "ColorDodge"    },
+            { SkBlendMode::kColorBurn,    "ColorBurn"     },
+            { SkBlendMode::kHardLight,    "HardLight"     },
+            { SkBlendMode::kSoftLight,    "SoftLight"     },
+            { SkBlendMode::kDifference,   "Difference"    },
+            { SkBlendMode::kExclusion,    "Exclusion"     },
+            { SkBlendMode::kMultiply,     "Multiply"      },
+            { SkBlendMode::kHue,          "Hue"           },
+            { SkBlendMode::kSaturation,   "Saturation"    },
+            { SkBlendMode::kColor,        "Color"         },
+            { SkBlendMode::kLuminosity,   "Luminosity"    },
         };
 
         int x = 0, y = 0;
         sk_sp<SkImageFilter> background(SkImageSource::Make(fCheckerboard));
         for (size_t i = 0; i < SK_ARRAY_COUNT(gModes); i++) {
-            paint.setImageFilter(SkXfermodeImageFilter::Make(SkXfermode::Make(gModes[i].fMode),
-                                                             background));
+            paint.setImageFilter(SkXfermodeImageFilter::Make(gModes[i].fMode, background));
             DrawClippedBitmap(canvas, fBitmap, paint, x, y);
             x += fBitmap.width() + MARGIN;
             if (x + fBitmap.width() > WIDTH) {
@@ -104,7 +103,7 @@ protected:
             y += fBitmap.height() + MARGIN;
         }
         // Test nullptr mode
-        paint.setImageFilter(SkXfermodeImageFilter::Make(nullptr, background));
+        paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver, background));
         DrawClippedBitmap(canvas, fBitmap, paint, x, y);
         x += fBitmap.width() + MARGIN;
         if (x + fBitmap.width() > WIDTH) {
@@ -122,11 +121,10 @@ protected:
         sk_sp<SkImageFilter> offsetBackground(SkOffsetImageFilter::Make(SkIntToScalar(4),
                                                                         SkIntToScalar(4),
                                                                         background));
-        paint.setImageFilter(SkXfermodeImageFilter::Make(
-                                                     SkXfermode::Make(SkXfermode::kSrcOver_Mode),
-                                                     offsetBackground,
-                                                     offsetForeground,
-                                                     nullptr));
+        paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
+                                                         offsetBackground,
+                                                         offsetForeground,
+                                                         nullptr));
         DrawClippedPaint(canvas, clipRect, paint, x, y);
         x += fBitmap.width() + MARGIN;
         if (x + fBitmap.width() > WIDTH) {
@@ -134,7 +132,7 @@ protected:
             y += fBitmap.height() + MARGIN;
         }
         // Test offsets on Darken (uses shader blend)
-        paint.setImageFilter(SkXfermodeImageFilter::Make(SkXfermode::Make(SkXfermode::kDarken_Mode),
+        paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kDarken,
                                                          offsetBackground,
                                                          offsetForeground,
                                                          nullptr));
@@ -146,9 +144,9 @@ protected:
         }
         // Test cropping
         constexpr size_t nbSamples = 3;
-        SkXfermode::Mode sampledModes[nbSamples] = {SkXfermode::kOverlay_Mode,
-                                                    SkXfermode::kSrcOver_Mode,
-                                                    SkXfermode::kPlus_Mode};
+        const SkBlendMode sampledModes[nbSamples] = {
+            SkBlendMode::kOverlay, SkBlendMode::kSrcOver, SkBlendMode::kPlus
+        };
         int offsets[nbSamples][4] = {{ 10,  10, -16, -16},
                                      { 10,  10,  10,  10},
                                      {-10, -10,  -6,  -6}};
@@ -158,7 +156,7 @@ protected:
                                                  fBitmap.width()  + offsets[i][2],
                                                  fBitmap.height() + offsets[i][3]);
             SkImageFilter::CropRect rect(SkRect::Make(cropRect));
-            paint.setImageFilter(SkXfermodeImageFilter::Make(SkXfermode::Make(sampledModes[i]),
+            paint.setImageFilter(SkXfermodeImageFilter::Make(sampledModes[i],
                                                              offsetBackground,
                                                              offsetForeground,
                                                              &rect));
@@ -170,7 +168,7 @@ protected:
             }
         }
         // Test small bg, large fg with Screen (uses shader blend)
-        auto mode = SkXfermode::Make(SkXfermode::kScreen_Mode);
+        SkBlendMode mode = SkBlendMode::kScreen;
         SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(10, 10, 60, 60));
         sk_sp<SkImageFilter> cropped(SkOffsetImageFilter::Make(0, 0, foreground, &cropRect));
         paint.setImageFilter(SkXfermodeImageFilter::Make(mode, cropped, background, nullptr));
@@ -191,7 +189,7 @@ protected:
         // Test small fg, large bg with SrcIn with a crop that forces it to full size.
         // This tests that SkXfermodeImageFilter correctly applies the compositing mode to
         // the region outside the foreground.
-        mode = SkXfermode::Make(SkXfermode::kSrcIn_Mode);
+        mode = SkBlendMode::kSrcIn;
         SkImageFilter::CropRect cropRectFull(SkRect::MakeXYWH(0, 0, 80, 80));
         paint.setImageFilter(SkXfermodeImageFilter::Make(mode, background,
                                                          cropped, &cropRectFull));
diff --git a/gm/xfermodes.cpp b/gm/xfermodes.cpp
index 8fbbdbec6a..604a767a4f 100644
--- a/gm/xfermodes.cpp
+++ b/gm/xfermodes.cpp
@@ -34,45 +34,45 @@ enum SrcType {
 };
 
 const struct {
-    SkXfermode::Mode  fMode;
-    const char*       fLabel;
-    int               fSourceTypeMask;  // The source types to use this
+    SkBlendMode fMode;
+    const char* fLabel;
+    int         fSourceTypeMask;  // The source types to use this
     // mode with. See draw_mode for
     // an explanation of each type.
     // PDF has to play some tricks
     // to support the base modes,
     // test those more extensively.
 } gModes[] = {
-    { SkXfermode::kClear_Mode,        "Clear",        kAll_SrcType   },
-    { SkXfermode::kSrc_Mode,          "Src",          kAll_SrcType   },
-    { SkXfermode::kDst_Mode,          "Dst",          kAll_SrcType   },
-    { SkXfermode::kSrcOver_Mode,      "SrcOver",      kAll_SrcType   },
-    { SkXfermode::kDstOver_Mode,      "DstOver",      kAll_SrcType   },
-    { SkXfermode::kSrcIn_Mode,        "SrcIn",        kAll_SrcType   },
-    { SkXfermode::kDstIn_Mode,        "DstIn",        kAll_SrcType   },
-    { SkXfermode::kSrcOut_Mode,       "SrcOut",       kAll_SrcType   },
-    { SkXfermode::kDstOut_Mode,       "DstOut",       kAll_SrcType   },
-    { SkXfermode::kSrcATop_Mode,      "SrcATop",      kAll_SrcType   },
-    { SkXfermode::kDstATop_Mode,      "DstATop",      kAll_SrcType   },
-
-    { SkXfermode::kXor_Mode,          "Xor",          kBasic_SrcType },
-    { SkXfermode::kPlus_Mode,         "Plus",         kBasic_SrcType },
-    { SkXfermode::kModulate_Mode,     "Modulate",     kAll_SrcType   },
-    { SkXfermode::kScreen_Mode,       "Screen",       kBasic_SrcType },
-    { SkXfermode::kOverlay_Mode,      "Overlay",      kBasic_SrcType },
-    { SkXfermode::kDarken_Mode,       "Darken",       kBasic_SrcType },
-    { SkXfermode::kLighten_Mode,      "Lighten",      kBasic_SrcType },
-    { SkXfermode::kColorDodge_Mode,   "ColorDodge",   kBasic_SrcType },
-    { SkXfermode::kColorBurn_Mode,    "ColorBurn",    kBasic_SrcType },
-    { SkXfermode::kHardLight_Mode,    "HardLight",    kBasic_SrcType },
-    { SkXfermode::kSoftLight_Mode,    "SoftLight",    kBasic_SrcType },
-    { SkXfermode::kDifference_Mode,   "Difference",   kBasic_SrcType },
-    { SkXfermode::kExclusion_Mode,    "Exclusion",    kBasic_SrcType },
-    { SkXfermode::kMultiply_Mode,     "Multiply",     kAll_SrcType   },
-    { SkXfermode::kHue_Mode,          "Hue",          kBasic_SrcType },
-    { SkXfermode::kSaturation_Mode,   "Saturation",   kBasic_SrcType },
-    { SkXfermode::kColor_Mode,        "Color",        kBasic_SrcType },
-    { SkXfermode::kLuminosity_Mode,   "Luminosity",   kBasic_SrcType },
+    { SkBlendMode::kClear,        "Clear",        kAll_SrcType   },
+    { SkBlendMode::kSrc,          "Src",          kAll_SrcType   },
+    { SkBlendMode::kDst,          "Dst",          kAll_SrcType   },
+    { SkBlendMode::kSrcOver,      "SrcOver",      kAll_SrcType   },
+    { SkBlendMode::kDstOver,      "DstOver",      kAll_SrcType   },
+    { SkBlendMode::kSrcIn,        "SrcIn",        kAll_SrcType   },
+    { SkBlendMode::kDstIn,        "DstIn",        kAll_SrcType   },
+    { SkBlendMode::kSrcOut,       "SrcOut",       kAll_SrcType   },
+    { SkBlendMode::kDstOut,       "DstOut",       kAll_SrcType   },
+    { SkBlendMode::kSrcATop,      "SrcATop",      kAll_SrcType   },
+    { SkBlendMode::kDstATop,      "DstATop",      kAll_SrcType   },
+
+    { SkBlendMode::kXor,          "Xor",          kBasic_SrcType },
+    { SkBlendMode::kPlus,         "Plus",         kBasic_SrcType },
+    { SkBlendMode::kModulate,     "Modulate",     kAll_SrcType   },
+    { SkBlendMode::kScreen,       "Screen",       kBasic_SrcType },
+    { SkBlendMode::kOverlay,      "Overlay",      kBasic_SrcType },
+    { SkBlendMode::kDarken,       "Darken",       kBasic_SrcType },
+    { SkBlendMode::kLighten,      "Lighten",      kBasic_SrcType },
+    { SkBlendMode::kColorDodge,   "ColorDodge",   kBasic_SrcType },
+    { SkBlendMode::kColorBurn,    "ColorBurn",    kBasic_SrcType },
+    { SkBlendMode::kHardLight,    "HardLight",    kBasic_SrcType },
+    { SkBlendMode::kSoftLight,    "SoftLight",    kBasic_SrcType },
+    { SkBlendMode::kDifference,   "Difference",   kBasic_SrcType },
+    { SkBlendMode::kExclusion,    "Exclusion",    kBasic_SrcType },
+    { SkBlendMode::kMultiply,     "Multiply",     kAll_SrcType   },
+    { SkBlendMode::kHue,          "Hue",          kBasic_SrcType },
+    { SkBlendMode::kSaturation,   "Saturation",   kBasic_SrcType },
+    { SkBlendMode::kColor,        "Color",        kBasic_SrcType },
+    { SkBlendMode::kLuminosity,   "Luminosity",   kBasic_SrcType },
 };
 
 static void make_bitmaps(int w, int h, SkBitmap* src, SkBitmap* dst,
@@ -118,15 +118,14 @@ class XfermodesGM : public skiagm::GM {
      * uses the implied shape of the drawing command and these modes
      * demonstrate that.
      */
-    void draw_mode(SkCanvas* canvas, SkXfermode::Mode mode, SrcType srcType,
-                   SkScalar x, SkScalar y) {
+    void draw_mode(SkCanvas* canvas, SkBlendMode mode, SrcType srcType, SkScalar x, SkScalar y) {
         SkPaint p;
         SkMatrix m;
         bool restoreNeeded = false;
         m.setTranslate(x, y);
 
         canvas->drawBitmap(fSrcB, x, y, &p);
-        p.setXfermodeMode(mode);
+        p.setBlendMode(mode);
         switch (srcType) {
             case kSmallTransparentImage_SrcType: {
                 m.postScale(SK_ScalarHalf, SK_ScalarHalf, x, y);
@@ -141,7 +140,7 @@ class XfermodesGM : public skiagm::GM {
                                                  SkIntToScalar(H));
                 canvas->saveLayer(&bounds, &p);
                 restoreNeeded = true;
-                p.setXfermodeMode(SkXfermode::kSrcOver_Mode);
+                p.setBlendMode(SkBlendMode::kSrcOver);
                 // Fall through.
             }
             case kQuarterClear_SrcType: {
diff --git a/gm/xfermodes2.cpp b/gm/xfermodes2.cpp
index 6f7d05475c..03da0d3317 100644
--- a/gm/xfermodes2.cpp
+++ b/gm/xfermodes2.cpp
@@ -40,7 +40,7 @@ protected:
 
         SkScalar x = 0, y = 0;
         for (size_t m = 0; m <= SkXfermode::kLastMode; m++) {
-            SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(m);
+            SkBlendMode mode = static_cast<SkBlendMode>(m);
 
             canvas->save();
 
@@ -57,7 +57,7 @@ protected:
             p.setShader(fDst);
             canvas->drawRect(r, p);
             p.setShader(fSrc);
-            p.setXfermode(SkXfermode::Make(mode));
+            p.setBlendMode(mode);
             canvas->drawRect(r, p);
 
             canvas->restore();
@@ -65,7 +65,7 @@ protected:
             r.inset(-SK_ScalarHalf, -SK_ScalarHalf);
             p.setStyle(SkPaint::kStroke_Style);
             p.setShader(nullptr);
-            p.setXfermode(nullptr);
+            p.setBlendMode(SkBlendMode::kSrcOver);
             canvas->drawRect(r, p);
 
             canvas->restore();
diff --git a/gm/xfermodes3.cpp b/gm/xfermodes3.cpp
index 300b78f2a2..36702bf70e 100644
--- a/gm/xfermodes3.cpp
+++ b/gm/xfermodes3.cpp
@@ -69,7 +69,7 @@ protected:
         };
         for (size_t s = 0; s < SK_ARRAY_COUNT(kStrokes); ++s) {
             for (size_t m = 0; m <= SkXfermode::kLastMode; ++m) {
-                SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(m);
+                SkBlendMode mode = static_cast<SkBlendMode>(m);
                 canvas->drawText(SkXfermode::ModeName(mode),
                                  strlen(SkXfermode::ModeName(mode)),
                                  SkIntToScalar(x),
@@ -77,7 +77,7 @@ protected:
                                  labelP);
                 for (size_t c = 0; c < SK_ARRAY_COUNT(kSolidColors); ++c) {
                     SkPaint modePaint;
-                    modePaint.setXfermodeMode(mode);
+                    modePaint.setBlendMode(mode);
                     modePaint.setColor(kSolidColors[c]);
                     modePaint.setStyle(kStrokes[s].fStyle);
                     modePaint.setStrokeWidth(kStrokes[s].fWidth);
@@ -93,7 +93,7 @@ protected:
                 }
                 for (size_t a = 0; a < SK_ARRAY_COUNT(kBmpAlphas); ++a) {
                     SkPaint modePaint;
-                    modePaint.setXfermodeMode(mode);
+                    modePaint.setBlendMode(mode);
                     modePaint.setAlpha(kBmpAlphas[a]);
                     modePaint.setShader(fBmpShader);
                     modePaint.setStyle(kStrokes[s].fStyle);