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>

3 files changed, 103 insertions, 102 deletions

diff --git a/src/gpu/effects/GrCustomXfermode.cpp b/src/gpu/effects/GrCustomXfermode.cpp
index 1b94a6bee1..3895f57f5d 100644
--- a/src/gpu/effects/GrCustomXfermode.cpp
+++ b/src/gpu/effects/GrCustomXfermode.cpp
@@ -24,33 +24,34 @@
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
-bool GrCustomXfermode::IsSupportedMode(SkXfermode::Mode mode) {
-    return mode > SkXfermode::kLastCoeffMode && mode <= SkXfermode::kLastMode;
+bool GrCustomXfermode::IsSupportedMode(SkBlendMode mode) {
+    return (int)mode  > (int)SkBlendMode::kLastCoeffMode &&
+           (int)mode <= (int)SkBlendMode::kLastMode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Static helpers
 ///////////////////////////////////////////////////////////////////////////////
 
-static GrBlendEquation hw_blend_equation(SkXfermode::Mode mode) {
-    enum { kOffset = kOverlay_GrBlendEquation - SkXfermode::kOverlay_Mode };
-    return static_cast<GrBlendEquation>(mode + kOffset);
-
-    GR_STATIC_ASSERT(kOverlay_GrBlendEquation == SkXfermode::kOverlay_Mode + kOffset);
-    GR_STATIC_ASSERT(kDarken_GrBlendEquation == SkXfermode::kDarken_Mode + kOffset);
-    GR_STATIC_ASSERT(kLighten_GrBlendEquation == SkXfermode::kLighten_Mode + kOffset);
-    GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == SkXfermode::kColorDodge_Mode + kOffset);
-    GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == SkXfermode::kColorBurn_Mode + kOffset);
-    GR_STATIC_ASSERT(kHardLight_GrBlendEquation == SkXfermode::kHardLight_Mode + kOffset);
-    GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == SkXfermode::kSoftLight_Mode + kOffset);
-    GR_STATIC_ASSERT(kDifference_GrBlendEquation == SkXfermode::kDifference_Mode + kOffset);
-    GR_STATIC_ASSERT(kExclusion_GrBlendEquation == SkXfermode::kExclusion_Mode + kOffset);
-    GR_STATIC_ASSERT(kMultiply_GrBlendEquation == SkXfermode::kMultiply_Mode + kOffset);
-    GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == SkXfermode::kHue_Mode + kOffset);
-    GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == SkXfermode::kSaturation_Mode + kOffset);
-    GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == SkXfermode::kColor_Mode + kOffset);
-    GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == SkXfermode::kLuminosity_Mode + kOffset);
-    GR_STATIC_ASSERT(kGrBlendEquationCnt == SkXfermode::kLastMode + 1 + kOffset);
+static GrBlendEquation hw_blend_equation(SkBlendMode mode) {
+    enum { kOffset = kOverlay_GrBlendEquation - (int)SkBlendMode::kOverlay };
+    return static_cast<GrBlendEquation>((int)mode + kOffset);
+
+    GR_STATIC_ASSERT(kOverlay_GrBlendEquation == (int)SkBlendMode::kOverlay + kOffset);
+    GR_STATIC_ASSERT(kDarken_GrBlendEquation == (int)SkBlendMode::kDarken + kOffset);
+    GR_STATIC_ASSERT(kLighten_GrBlendEquation == (int)SkBlendMode::kLighten + kOffset);
+    GR_STATIC_ASSERT(kColorDodge_GrBlendEquation == (int)SkBlendMode::kColorDodge + kOffset);
+    GR_STATIC_ASSERT(kColorBurn_GrBlendEquation == (int)SkBlendMode::kColorBurn + kOffset);
+    GR_STATIC_ASSERT(kHardLight_GrBlendEquation == (int)SkBlendMode::kHardLight + kOffset);
+    GR_STATIC_ASSERT(kSoftLight_GrBlendEquation == (int)SkBlendMode::kSoftLight + kOffset);
+    GR_STATIC_ASSERT(kDifference_GrBlendEquation == (int)SkBlendMode::kDifference + kOffset);
+    GR_STATIC_ASSERT(kExclusion_GrBlendEquation == (int)SkBlendMode::kExclusion + kOffset);
+    GR_STATIC_ASSERT(kMultiply_GrBlendEquation == (int)SkBlendMode::kMultiply + kOffset);
+    GR_STATIC_ASSERT(kHSLHue_GrBlendEquation == (int)SkBlendMode::kHue + kOffset);
+    GR_STATIC_ASSERT(kHSLSaturation_GrBlendEquation == (int)SkBlendMode::kSaturation + kOffset);
+    GR_STATIC_ASSERT(kHSLColor_GrBlendEquation == (int)SkBlendMode::kColor + kOffset);
+    GR_STATIC_ASSERT(kHSLLuminosity_GrBlendEquation == (int)SkBlendMode::kLuminosity + kOffset);
+    GR_STATIC_ASSERT(kGrBlendEquationCnt == (int)SkBlendMode::kLastMode + 1 + kOffset);
 }
 
 static bool can_use_hw_blend_equation(GrBlendEquation equation,
@@ -77,13 +78,13 @@ static bool can_use_hw_blend_equation(GrBlendEquation equation,
 
 class CustomXP : public GrXferProcessor {
 public:
-    CustomXP(SkXfermode::Mode mode, GrBlendEquation hwBlendEquation)
+    CustomXP(SkBlendMode mode, GrBlendEquation hwBlendEquation)
         : fMode(mode),
           fHWBlendEquation(hwBlendEquation) {
         this->initClassID<CustomXP>();
     }
 
-    CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkXfermode::Mode mode)
+    CustomXP(const DstTexture* dstTexture, bool hasMixedSamples, SkBlendMode mode)
         : INHERITED(dstTexture, true, hasMixedSamples),
           fMode(mode),
           fHWBlendEquation(static_cast<GrBlendEquation>(-1)) {
@@ -94,7 +95,7 @@ public:
 
     GrGLSLXferProcessor* createGLSLInstance() const override;
 
-    SkXfermode::Mode mode() const { return fMode; }
+    SkBlendMode mode() const { return fMode; }
     bool hasHWBlendEquation() const { return -1 != static_cast<int>(fHWBlendEquation); }
 
     GrBlendEquation hwBlendEquation() const {
@@ -116,7 +117,7 @@ private:
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
-    const SkXfermode::Mode fMode;
+    const SkBlendMode      fMode;
     const GrBlendEquation  fHWBlendEquation;
 
     typedef GrXferProcessor INHERITED;
@@ -138,7 +139,7 @@ public:
             GR_STATIC_ASSERT(GrGLSLCaps::kLast_AdvBlendEqInteraction < 4);
         }
         if (!xp.hasHWBlendEquation() || caps.mustEnableSpecificAdvBlendEqs()) {
-            key |= xp.mode() << 3;
+            key |= (int)xp.mode() << 3;
         }
         b->add32(key);
     }
@@ -326,7 +327,7 @@ void CustomXP::onGetBlendInfo(BlendInfo* blendInfo) const {
 ///////////////////////////////////////////////////////////////////////////////
 class CustomXPFactory : public GrXPFactory {
 public:
-    CustomXPFactory(SkXfermode::Mode mode);
+    CustomXPFactory(SkBlendMode mode);
 
     void getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                   GrXPFactory::InvariantBlendedColor*) const override;
@@ -346,13 +347,13 @@ private:
 
     GR_DECLARE_XP_FACTORY_TEST;
 
-    SkXfermode::Mode fMode;
-    GrBlendEquation  fHWBlendEquation;
+    SkBlendMode     fMode;
+    GrBlendEquation fHWBlendEquation;
 
     typedef GrXPFactory INHERITED;
 };
 
-CustomXPFactory::CustomXPFactory(SkXfermode::Mode mode)
+CustomXPFactory::CustomXPFactory(SkBlendMode mode)
     : fMode(mode),
       fHWBlendEquation(hw_blend_equation(mode)) {
     SkASSERT(GrCustomXfermode::IsSupportedMode(fMode));
@@ -386,12 +387,12 @@ sk_sp<GrXPFactory> CustomXPFactory::TestCreate(GrProcessorTestData* d) {
     int mode = d->fRandom->nextRangeU(SkXfermode::kLastCoeffMode + 1,
                                       SkXfermode::kLastSeparableMode);
 
-    return sk_sp<GrXPFactory>(new CustomXPFactory(static_cast<SkXfermode::Mode>(mode)));
+    return sk_sp<GrXPFactory>(new CustomXPFactory(static_cast<SkBlendMode>(mode)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkXfermode::Mode mode) {
+sk_sp<GrXPFactory> GrCustomXfermode::MakeXPFactory(SkBlendMode mode) {
     if (!GrCustomXfermode::IsSupportedMode(mode)) {
         return nullptr;
     } else {
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index f51e94ba82..d511fae45d 100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -323,20 +323,20 @@ static const BlendFormula gLCDBlendTable[SkXfermode::kLastCoeffMode + 1] = {
 static BlendFormula get_blend_formula(const GrProcOptInfo& colorPOI,
                                       const GrProcOptInfo& coveragePOI,
                                       bool hasMixedSamples,
-                                      SkXfermode::Mode xfermode) {
-    SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode);
+                                      SkBlendMode xfermode) {
+    SkASSERT((unsigned)xfermode <= (unsigned)SkBlendMode::kLastCoeffMode);
     SkASSERT(!coveragePOI.isFourChannelOutput());
 
     bool conflatesCoverage = !coveragePOI.isSolidWhite() || hasMixedSamples;
-    return gBlendTable[colorPOI.isOpaque()][conflatesCoverage][xfermode];
+    return gBlendTable[colorPOI.isOpaque()][conflatesCoverage][(int)xfermode];
 }
 
 static BlendFormula get_lcd_blend_formula(const GrProcOptInfo& coveragePOI,
-                                          SkXfermode::Mode xfermode) {
-    SkASSERT(xfermode >= 0 && xfermode <= SkXfermode::kLastCoeffMode);
+                                          SkBlendMode xfermode) {
+    SkASSERT((unsigned)xfermode <= (unsigned)SkBlendMode::kLastCoeffMode);
     SkASSERT(coveragePOI.isFourChannelOutput());
 
-    return gLCDBlendTable[xfermode];
+    return gLCDBlendTable[(int)xfermode];
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -506,7 +506,7 @@ class ShaderPDXferProcessor : public GrXferProcessor {
 public:
     ShaderPDXferProcessor(const DstTexture* dstTexture,
                           bool hasMixedSamples,
-                          SkXfermode::Mode xfermode)
+                          SkBlendMode xfermode)
         : INHERITED(dstTexture, true, hasMixedSamples)
         , fXfermode(xfermode) {
         this->initClassID<ShaderPDXferProcessor>();
@@ -516,7 +516,7 @@ public:
 
     GrGLSLXferProcessor* createGLSLInstance() const override;
 
-    SkXfermode::Mode getXfermode() const { return fXfermode; }
+    SkBlendMode getXfermode() const { return fXfermode; }
 
 private:
     GrXferProcessor::OptFlags onGetOptimizations(const GrPipelineOptimizations&, bool, GrColor*,
@@ -531,7 +531,7 @@ private:
         return fXfermode == xp.fXfermode;
     }
 
-    const SkXfermode::Mode fXfermode;
+    const SkBlendMode fXfermode;
 
     typedef GrXferProcessor INHERITED;
 };
@@ -542,7 +542,7 @@ class GLShaderPDXferProcessor : public GrGLSLXferProcessor {
 public:
     static void GenKey(const GrProcessor& processor, GrProcessorKeyBuilder* b) {
         const ShaderPDXferProcessor& xp = processor.cast<ShaderPDXferProcessor>();
-        b->add32(xp.getXfermode());
+        b->add32((int)xp.getXfermode());
     }
 
 private:
@@ -583,7 +583,7 @@ GrGLSLXferProcessor* ShaderPDXferProcessor::createGLSLInstance() const {
 
 class PDLCDXferProcessor : public GrXferProcessor {
 public:
-    static GrXferProcessor* Create(SkXfermode::Mode xfermode, const GrProcOptInfo& colorPOI);
+    static GrXferProcessor* Create(SkBlendMode xfermode, const GrProcOptInfo& colorPOI);
 
     ~PDLCDXferProcessor() override;
 
@@ -654,9 +654,9 @@ PDLCDXferProcessor::PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha)
     this->initClassID<PDLCDXferProcessor>();
 }
 
-GrXferProcessor* PDLCDXferProcessor::Create(SkXfermode::Mode xfermode,
+GrXferProcessor* PDLCDXferProcessor::Create(SkBlendMode xfermode,
                                             const GrProcOptInfo& colorPOI) {
-    if (SkXfermode::kSrcOver_Mode != xfermode) {
+    if (SkBlendMode::kSrcOver != xfermode) {
         return nullptr;
     }
 
@@ -698,40 +698,40 @@ PDLCDXferProcessor::onGetOptimizations(const GrPipelineOptimizations& optimizati
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkXfermode::Mode xfermode)
+GrPorterDuffXPFactory::GrPorterDuffXPFactory(SkBlendMode xfermode)
     : fXfermode(xfermode) {
-    SkASSERT(fXfermode <= SkXfermode::kLastCoeffMode);
+    SkASSERT((unsigned)fXfermode <= (unsigned)SkBlendMode::kLastCoeffMode);
     this->initClassID<GrPorterDuffXPFactory>();
 }
 
-sk_sp<GrXPFactory> GrPorterDuffXPFactory::Make(SkXfermode::Mode xfermode) {
-    static GrPorterDuffXPFactory gClearPDXPF(SkXfermode::kClear_Mode);
-    static GrPorterDuffXPFactory gSrcPDXPF(SkXfermode::kSrc_Mode);
-    static GrPorterDuffXPFactory gDstPDXPF(SkXfermode::kDst_Mode);
-    static GrPorterDuffXPFactory gSrcOverPDXPF(SkXfermode::kSrcOver_Mode);
-    static GrPorterDuffXPFactory gDstOverPDXPF(SkXfermode::kDstOver_Mode);
-    static GrPorterDuffXPFactory gSrcInPDXPF(SkXfermode::kSrcIn_Mode);
-    static GrPorterDuffXPFactory gDstInPDXPF(SkXfermode::kDstIn_Mode);
-    static GrPorterDuffXPFactory gSrcOutPDXPF(SkXfermode::kSrcOut_Mode);
-    static GrPorterDuffXPFactory gDstOutPDXPF(SkXfermode::kDstOut_Mode);
-    static GrPorterDuffXPFactory gSrcATopPDXPF(SkXfermode::kSrcATop_Mode);
-    static GrPorterDuffXPFactory gDstATopPDXPF(SkXfermode::kDstATop_Mode);
-    static GrPorterDuffXPFactory gXorPDXPF(SkXfermode::kXor_Mode);
-    static GrPorterDuffXPFactory gPlusPDXPF(SkXfermode::kPlus_Mode);
-    static GrPorterDuffXPFactory gModulatePDXPF(SkXfermode::kModulate_Mode);
-    static GrPorterDuffXPFactory gScreenPDXPF(SkXfermode::kScreen_Mode);
+sk_sp<GrXPFactory> GrPorterDuffXPFactory::Make(SkBlendMode xfermode) {
+    static GrPorterDuffXPFactory gClearPDXPF(SkBlendMode::kClear);
+    static GrPorterDuffXPFactory gSrcPDXPF(SkBlendMode::kSrc);
+    static GrPorterDuffXPFactory gDstPDXPF(SkBlendMode::kDst);
+    static GrPorterDuffXPFactory gSrcOverPDXPF(SkBlendMode::kSrcOver);
+    static GrPorterDuffXPFactory gDstOverPDXPF(SkBlendMode::kDstOver);
+    static GrPorterDuffXPFactory gSrcInPDXPF(SkBlendMode::kSrcIn);
+    static GrPorterDuffXPFactory gDstInPDXPF(SkBlendMode::kDstIn);
+    static GrPorterDuffXPFactory gSrcOutPDXPF(SkBlendMode::kSrcOut);
+    static GrPorterDuffXPFactory gDstOutPDXPF(SkBlendMode::kDstOut);
+    static GrPorterDuffXPFactory gSrcATopPDXPF(SkBlendMode::kSrcATop);
+    static GrPorterDuffXPFactory gDstATopPDXPF(SkBlendMode::kDstATop);
+    static GrPorterDuffXPFactory gXorPDXPF(SkBlendMode::kXor);
+    static GrPorterDuffXPFactory gPlusPDXPF(SkBlendMode::kPlus);
+    static GrPorterDuffXPFactory gModulatePDXPF(SkBlendMode::kModulate);
+    static GrPorterDuffXPFactory gScreenPDXPF(SkBlendMode::kScreen);
 
     static GrPorterDuffXPFactory* gFactories[] = {
         &gClearPDXPF, &gSrcPDXPF, &gDstPDXPF, &gSrcOverPDXPF, &gDstOverPDXPF, &gSrcInPDXPF,
         &gDstInPDXPF, &gSrcOutPDXPF, &gDstOutPDXPF, &gSrcATopPDXPF, &gDstATopPDXPF, &gXorPDXPF,
         &gPlusPDXPF, &gModulatePDXPF, &gScreenPDXPF
     };
-    GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == SkXfermode::kLastCoeffMode + 1);
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(gFactories) == (int)SkBlendMode::kLastCoeffMode + 1);
 
-    if (xfermode < 0 || xfermode > SkXfermode::kLastCoeffMode) {
+    if ((int)xfermode < 0 || (int)xfermode > (int)SkBlendMode::kLastCoeffMode) {
         return nullptr;
     }
-    return sk_sp<GrXPFactory>(SkRef(gFactories[xfermode]));
+    return sk_sp<GrXPFactory>(SkRef(gFactories[(int)xfermode]));
 }
 
 GrXferProcessor*
@@ -744,7 +744,7 @@ GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
     }
     BlendFormula blendFormula;
     if (optimizations.fCoveragePOI.isFourChannelOutput()) {
-        if (SkXfermode::kSrcOver_Mode == fXfermode &&
+        if (SkBlendMode::kSrcOver == fXfermode &&
             kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
             !caps.shaderCaps()->dualSourceBlendingSupport() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
@@ -770,7 +770,7 @@ GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
 void GrPorterDuffXPFactory::getInvariantBlendedColor(const GrProcOptInfo& colorPOI,
                                                      InvariantBlendedColor* blendedColor) const {
     // Find the blended color info based on the formula that does not have coverage.
-    BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][fXfermode];
+    BlendFormula colorFormula = gBlendTable[colorPOI.isOpaque()][0][(int)fXfermode];
     if (colorFormula.usesDstColor()) {
         blendedColor->fWillBlendWithDst = true;
         blendedColor->fKnownColorFlags = kNone_GrColorComponentFlags;
@@ -808,7 +808,7 @@ bool GrPorterDuffXPFactory::onWillReadDstColor(const GrCaps& caps,
     // blend. The one exception is when we are using srcover mode and we know the input color into
     // the XP.
     if (optimizations.fCoveragePOI.isFourChannelOutput()) {
-        if (SkXfermode::kSrcOver_Mode == fXfermode &&
+        if (SkBlendMode::kSrcOver == fXfermode &&
             kRGBA_GrColorComponentFlags == optimizations.fColorPOI.validFlags() &&
             !caps.shaderCaps()->dstReadInShaderSupport()) {
             return false;
@@ -827,7 +827,7 @@ bool GrPorterDuffXPFactory::onWillReadDstColor(const GrCaps& caps,
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 sk_sp<GrXPFactory> GrPorterDuffXPFactory::TestCreate(GrProcessorTestData* d) {
-    SkXfermode::Mode mode = SkXfermode::Mode(d->fRandom->nextULessThan(SkXfermode::kLastCoeffMode));
+    SkBlendMode mode = SkBlendMode(d->fRandom->nextULessThan((int)SkBlendMode::kLastCoeffMode));
     return GrPorterDuffXPFactory::Make(mode);
 }
 
@@ -860,7 +860,7 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
         bool hasMixedSamples,
         const GrXferProcessor::DstTexture* dstTexture) {
     if (optimizations.fOverrides.fUsePLSDstRead) {
-        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode);
+        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver);
     }
 
     // We want to not make an xfer processor if possible. Thus for the simple case where we are not
@@ -882,13 +882,13 @@ GrXferProcessor* GrPorterDuffXPFactory::CreateSrcOverXferProcessor(
         // back to this trick for rendering SrcOver LCD text instead of doing a
         // dst copy.
         SkASSERT(!dstTexture || !dstTexture->texture());
-        return PDLCDXferProcessor::Create(SkXfermode::kSrcOver_Mode, optimizations.fColorPOI);
+        return PDLCDXferProcessor::Create(SkBlendMode::kSrcOver, optimizations.fColorPOI);
     }
 
     BlendFormula blendFormula;
-    blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkXfermode::kSrcOver_Mode);
+    blendFormula = get_lcd_blend_formula(optimizations.fCoveragePOI, SkBlendMode::kSrcOver);
     if (blendFormula.hasSecondaryOutput() && !caps.shaderCaps()->dualSourceBlendingSupport()) {
-        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkXfermode::kSrcOver_Mode);
+        return new ShaderPDXferProcessor(dstTexture, hasMixedSamples, SkBlendMode::kSrcOver);
     }
 
     SkASSERT(!dstTexture || !dstTexture->texture());
@@ -911,7 +911,7 @@ bool GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(const GrCaps& caps,
             return false;
         }
         return get_lcd_blend_formula(optimizations.fCoveragePOI,
-                                     SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
+                                     SkBlendMode::kSrcOver).hasSecondaryOutput();
     }
 
     // We fallback on the shader XP when the blend formula would use dual source blending but we
@@ -919,5 +919,5 @@ bool GrPorterDuffXPFactory::SrcOverWillNeedDstTexture(const GrCaps& caps,
     static const bool kHasMixedSamples = false;
     SkASSERT(!caps.usesMixedSamples()); // We never use mixed samples without dual source blending.
     return get_blend_formula(optimizations.fColorPOI, optimizations.fCoveragePOI,
-                             kHasMixedSamples, SkXfermode::kSrcOver_Mode).hasSecondaryOutput();
+                             kHasMixedSamples, SkBlendMode::kSrcOver).hasSecondaryOutput();
 }
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index 935747bccd..0e8e16c0e9 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -18,7 +18,7 @@
 class ComposeTwoFragmentProcessor : public GrFragmentProcessor {
 public:
     ComposeTwoFragmentProcessor(sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst,
-                                SkXfermode::Mode mode)
+                                SkBlendMode mode)
         : fMode(mode) {
         this->initClassID<ComposeTwoFragmentProcessor>();
         SkDEBUGCODE(int shaderAChildIndex = )this->registerChildProcessor(std::move(src));
@@ -30,10 +30,10 @@ public:
     const char* name() const override { return "ComposeTwo"; }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
-        b->add32(fMode);
+        b->add32((int)fMode);
     }
 
-    SkXfermode::Mode getMode() const { return fMode; }
+    SkBlendMode getMode() const { return fMode; }
 
 protected:
     bool onIsEqual(const GrFragmentProcessor& other) const override {
@@ -48,7 +48,7 @@ protected:
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
-    SkXfermode::Mode fMode;
+    SkBlendMode fMode;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
@@ -74,8 +74,8 @@ sk_sp<GrFragmentProcessor> ComposeTwoFragmentProcessor::TestCreate(GrProcessorTe
     sk_sp<GrFragmentProcessor> fpA(GrProcessorUnitTest::MakeChildFP(d));
     sk_sp<GrFragmentProcessor> fpB(GrProcessorUnitTest::MakeChildFP(d));
 
-    SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
-        d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
+    SkBlendMode mode = static_cast<SkBlendMode>(
+        d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode));
     return sk_sp<GrFragmentProcessor>(
         new ComposeTwoFragmentProcessor(std::move(fpA), std::move(fpB), mode));
 }
@@ -105,7 +105,7 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) {
     this->emitChild(1, inputColor, &dstColor, args);
 
     // emit blend code
-    SkXfermode::Mode mode = cs.getMode();
+    SkBlendMode mode = cs.getMode();
     fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkXfermode::ModeName(mode));
     GrGLSLBlend::AppendMode(fragBuilder,
                             srcColor.c_str(),
@@ -120,14 +120,14 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) {
 }
 
 sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromTwoProcessors(
-         sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
+         sk_sp<GrFragmentProcessor> src, sk_sp<GrFragmentProcessor> dst, SkBlendMode mode) {
     switch (mode) {
-        case SkXfermode::kClear_Mode:
+        case SkBlendMode::kClear:
             return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
                                                GrConstColorProcessor::kIgnore_InputMode);
-        case SkXfermode::kSrc_Mode:
+        case SkBlendMode::kSrc:
             return src;
-        case SkXfermode::kDst_Mode:
+        case SkBlendMode::kDst:
             return dst;
         default:
             return sk_sp<GrFragmentProcessor>(
@@ -144,7 +144,7 @@ public:
         kSrc_Child,
     };
 
-    ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode, Child child)
+    ComposeOneFragmentProcessor(sk_sp<GrFragmentProcessor> dst, SkBlendMode mode, Child child)
         : fMode(mode)
         , fChild(child) {
         this->initClassID<ComposeOneFragmentProcessor>();
@@ -164,11 +164,11 @@ public:
     }
 
     void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
-        GR_STATIC_ASSERT((SkXfermode::kLastMode & SK_MaxU16) == SkXfermode::kLastMode);
-        b->add32(fMode | (fChild << 16));
+        GR_STATIC_ASSERT(((int)SkBlendMode::kLastMode & SK_MaxU16) == (int)SkBlendMode::kLastMode);
+        b->add32((int)fMode | (fChild << 16));
     }
 
-    SkXfermode::Mode mode() const { return fMode; }
+    SkBlendMode mode() const { return fMode; }
 
     Child child() const { return fChild; }
 
@@ -217,8 +217,8 @@ protected:
 private:
     GrGLSLFragmentProcessor* onCreateGLSLInstance() const override;
 
-    SkXfermode::Mode    fMode;
-    Child               fChild;
+    SkBlendMode fMode;
+    Child       fChild;
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
@@ -231,7 +231,7 @@ class GLComposeOneFragmentProcessor : public GrGLSLFragmentProcessor {
 public:
     void emitCode(EmitArgs& args) override {
         GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
-        SkXfermode::Mode mode = args.fFp.cast<ComposeOneFragmentProcessor>().mode();
+        SkBlendMode mode = args.fFp.cast<ComposeOneFragmentProcessor>().mode();
         ComposeOneFragmentProcessor::Child child =
             args.fFp.cast<ComposeOneFragmentProcessor>().child();
         SkString childColor("child");
@@ -267,8 +267,8 @@ sk_sp<GrFragmentProcessor> ComposeOneFragmentProcessor::TestCreate(GrProcessorTe
     // For now, we'll prevent either children from being a shader with children to prevent the
     // possibility of an arbitrarily large tree of procs.
     sk_sp<GrFragmentProcessor> dst(GrProcessorUnitTest::MakeChildFP(d));
-    SkXfermode::Mode mode = static_cast<SkXfermode::Mode>(
-        d->fRandom->nextRangeU(0, SkXfermode::kLastMode));
+    SkBlendMode mode = static_cast<SkBlendMode>(
+        d->fRandom->nextRangeU(0, (int)SkBlendMode::kLastMode));
     ComposeOneFragmentProcessor::Child child = d->fRandom->nextBool() ?
         ComposeOneFragmentProcessor::kDst_Child :
         ComposeOneFragmentProcessor::kSrc_Child;
@@ -282,12 +282,12 @@ GrGLSLFragmentProcessor* ComposeOneFragmentProcessor::onCreateGLSLInstance() con
 //////////////////////////////////////////////////////////////////////////////
 
 sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
-    sk_sp<GrFragmentProcessor> dst, SkXfermode::Mode mode) {
+    sk_sp<GrFragmentProcessor> dst, SkBlendMode mode) {
     switch (mode) {
-        case SkXfermode::kClear_Mode:
+        case SkBlendMode::kClear:
             return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
                                                  GrConstColorProcessor::kIgnore_InputMode);
-        case SkXfermode::kSrc_Mode:
+        case SkBlendMode::kSrc:
             return nullptr;
         default:
             return sk_sp<GrFragmentProcessor>(
@@ -297,12 +297,12 @@ sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromDstProcessor(
 }
 
 sk_sp<GrFragmentProcessor> GrXfermodeFragmentProcessor::MakeFromSrcProcessor(
-    sk_sp<GrFragmentProcessor> src, SkXfermode::Mode mode) {
+    sk_sp<GrFragmentProcessor> src, SkBlendMode mode) {
     switch (mode) {
-        case SkXfermode::kClear_Mode:
+        case SkBlendMode::kClear:
             return GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
                                                  GrConstColorProcessor::kIgnore_InputMode);
-        case SkXfermode::kDst_Mode:
+        case SkBlendMode::kDst:
             return nullptr;
         default:
             return sk_sp<GrFragmentProcessor>(