remove unused xfermode methods

Bug: skia:
Change-Id: Ib0dfa7bbf3d4e73aab355df4d5f5e2a53f653809
Reviewed-on: https://skia-review.googlesource.com/19035
Reviewed-by: Mike Reed <reed@google.com>

9 files changed, 26 insertions, 260 deletions

diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index aef1044a94..1507368e05 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -352,12 +352,9 @@ SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
             fShadeDirectlyIntoDevice = true;
         }
     } else {
-        SkXfermode::Mode mode;
-        if (fXfermode->asMode(&mode)) {
-            if (SkXfermode::kSrc_Mode == mode) {
-                fShadeDirectlyIntoDevice = true;
-                fProc32Blend = blend_srcmode;
-            }
+        if (SkBlendMode::kSrc == paint.getBlendMode()) {
+            fShadeDirectlyIntoDevice = true;
+            fProc32Blend = blend_srcmode;
         }
     }
 
diff --git a/src/core/SkModeColorFilter.cpp b/src/core/SkModeColorFilter.cpp
index f30b6a527d..66dbe9954d 100644
--- a/src/core/SkModeColorFilter.cpp
+++ b/src/core/SkModeColorFilter.cpp
@@ -29,7 +29,7 @@ void SkModeColorFilter::toString(SkString* str) const {
     str->append("SkModeColorFilter: color: 0x");
     str->appendHex(fColor);
     str->append(" mode: ");
-    str->append(SkXfermode::ModeName(fMode));
+    str->append(SkBlendMode_Name(fMode));
 }
 #endif
 
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 31f822feaf..02abe55f74 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -989,7 +989,7 @@ const ProcCoeff gProcCoeffs[] = {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool SkXfermode::asMode(Mode* mode) const {
+bool SkXfermode::asMode(SkBlendMode* mode) const {
     return false;
 }
 
@@ -1010,43 +1010,6 @@ const GrXPFactory* SkXfermode::asXPFactory() const {
 }
 #endif
 
-SkPMColor SkXfermode::xferColor(SkPMColor src, SkPMColor dst) const{
-    // no-op. subclasses should override this
-    return dst;
-}
-
-void SkXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
-                        const SkPMColor* SK_RESTRICT src, int count,
-                        const SkAlpha* SK_RESTRICT aa) const {
-    SkASSERT(dst && src && count >= 0);
-
-    if (nullptr == aa) {
-        for (int i = count - 1; i >= 0; --i) {
-            dst[i] = this->xferColor(src[i], dst[i]);
-        }
-    } else {
-        for (int i = count - 1; i >= 0; --i) {
-            unsigned a = aa[i];
-            if (0 != a) {
-                SkPMColor dstC = dst[i];
-                SkPMColor C = this->xferColor(src[i], dstC);
-                if (0xFF != a) {
-                    C = SkFourByteInterp(C, dstC, a);
-                }
-                dst[i] = C;
-            }
-        }
-    }
-}
-
-bool SkXfermode::supportsCoverageAsAlpha() const {
-    return false;
-}
-
-bool SkXfermode::isOpaque(SkXfermode::SrcColorOpacity opacityType) const {
-    return false;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -1055,28 +1018,20 @@ sk_sp<SkFlattenable> SkProcCoeffXfermode::CreateProc(SkReadBuffer& buffer) {
     if (!buffer.validate(mode32 < SK_ARRAY_COUNT(gProcCoeffs))) {
         return nullptr;
     }
-    return SkXfermode::Make((SkXfermode::Mode)mode32);
+    return SkXfermode::Make((SkBlendMode)mode32);
 }
 
 void SkProcCoeffXfermode::flatten(SkWriteBuffer& buffer) const {
     buffer.write32((int)fMode);
 }
 
-bool SkProcCoeffXfermode::asMode(Mode* mode) const {
+bool SkProcCoeffXfermode::asMode(SkBlendMode* mode) const {
     if (mode) {
-        *mode = (Mode)fMode;
+        *mode = fMode;
     }
     return true;
 }
 
-bool SkProcCoeffXfermode::supportsCoverageAsAlpha() const {
-    return SkBlendMode_SupportsCoverageAsAlpha(fMode);
-}
-
-bool SkProcCoeffXfermode::isOpaque(SkXfermode::SrcColorOpacity opacityType) const {
-    return SkXfermode::IsOpaque(fMode, opacityType);
-}
-
 void SkProcCoeffXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                                  const SkPMColor* SK_RESTRICT src, int count,
                                  const SkAlpha* SK_RESTRICT aa) const {
@@ -1124,8 +1079,8 @@ const GrXPFactory* SkProcCoeffXfermode::asXPFactory() const {
 }
 #endif
 
-const char* SkXfermode::ModeName(Mode mode) {
-    SkASSERT((unsigned) mode <= (unsigned)kLastMode);
+const char* SkBlendMode_Name(SkBlendMode mode) {
+    SkASSERT((unsigned) mode <= (unsigned)SkBlendMode::kLastMode);
     const char* gModeStrings[] = {
         "Clear", "Src", "Dst", "SrcOver", "DstOver", "SrcIn", "DstIn",
         "SrcOut", "DstOut", "SrcATop", "DstATop", "Xor", "Plus",
@@ -1133,12 +1088,8 @@ const char* SkXfermode::ModeName(Mode mode) {
         "ColorBurn", "HardLight", "SoftLight", "Difference", "Exclusion",
         "Multiply", "Hue", "Saturation", "Color",  "Luminosity"
     };
-    return gModeStrings[mode];
-    static_assert(SK_ARRAY_COUNT(gModeStrings) == kLastMode + 1, "mode_count");
-}
-
-const char* SkBlendMode_Name(SkBlendMode mode) {
-    return SkXfermode::ModeName((SkXfermode::Mode)mode);
+    return gModeStrings[(int)mode];
+    static_assert(SK_ARRAY_COUNT(gModeStrings) == (size_t)SkBlendMode::kLastMode + 1, "mode_count");
 }
 
 #ifndef SK_IGNORE_TO_STRING
@@ -1146,7 +1097,7 @@ void SkProcCoeffXfermode::toString(SkString* str) const {
     str->append("SkProcCoeffXfermode: ");
 
     str->append("mode: ");
-    str->append(ModeName(fMode));
+    str->append(SkBlendMode_Name(fMode));
 }
 #endif
 
@@ -1182,7 +1133,7 @@ sk_sp<SkXfermode> SkXfermode::Make(SkBlendMode mode) {
 
 SkXfermodeProc SkXfermode::GetProc(SkBlendMode mode) {
     SkXfermodeProc  proc = nullptr;
-    if ((unsigned)mode < kModeCount) {
+    if ((unsigned)mode <= (unsigned)SkBlendMode::kLastMode) {
         proc = gProcCoeffs[(unsigned)mode].fProc;
     }
     return proc;
@@ -1190,49 +1141,12 @@ SkXfermodeProc SkXfermode::GetProc(SkBlendMode mode) {
 
 SkXfermodeProc4f SkXfermode::GetProc4f(SkBlendMode mode) {
     SkXfermodeProc4f  proc = nullptr;
-    if ((unsigned)mode < kModeCount) {
+    if ((unsigned)mode <= (unsigned)SkBlendMode::kLastMode) {
         proc = gProcCoeffs[(unsigned)mode].fProc4f;
     }
     return proc;
 }
 
-bool SkXfermode::AsMode(const SkXfermode* xfer, Mode* mode) {
-    if (nullptr == xfer) {
-        if (mode) {
-            *mode = kSrcOver_Mode;
-        }
-        return true;
-    }
-    return xfer->asMode(mode);
-}
-
-bool SkXfermode::IsMode(const SkXfermode* xfer, Mode mode) {
-    // if xfer==null then the mode is srcover
-    Mode m = kSrcOver_Mode;
-    if (xfer && !xfer->asMode(&m)) {
-        return false;
-    }
-    return mode == m;
-}
-
-bool SkXfermode::SupportsCoverageAsAlpha(const SkXfermode* xfer) {
-    // if xfer is nullptr we treat it as srcOver which always supports coverageAsAlpha
-    if (!xfer) {
-        return true;
-    }
-
-    return xfer->supportsCoverageAsAlpha();
-}
-
-bool SkXfermode::IsOpaque(const SkXfermode* xfer, SrcColorOpacity opacityType) {
-    // if xfer is nullptr we treat it as srcOver which is opaque if our src is opaque
-    if (!xfer) {
-        return SkXfermode::kOpaque_SrcColorOpacity == opacityType;
-    }
-
-    return xfer->isOpaque(opacityType);
-}
-
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
diff --git a/src/core/SkXfermodePriv.h b/src/core/SkXfermodePriv.h
index f5cee5a435..425dec24f6 100644
--- a/src/core/SkXfermodePriv.h
+++ b/src/core/SkXfermodePriv.h
@@ -37,99 +37,18 @@ typedef SkPM4f (*SkXfermodeProc4f)(const SkPM4f& src, const SkPM4f& dst);
 class SK_API SkXfermode : public SkFlattenable {
 public:
     virtual void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
-                        const SkAlpha aa[]) const;
-
-    /** List of predefined xfermodes.
-        The algebra for the modes uses the following symbols:
-        Sa, Sc  - source alpha and color
-        Da, Dc - destination alpha and color (before compositing)
-        [a, c] - Resulting (alpha, color) values
-        For these equations, the colors are in premultiplied state.
-        If no xfermode is specified, kSrcOver is assumed.
-     */
-    enum Mode {
-        kClear_Mode,    //!< [0, 0]
-        kSrc_Mode,      //!< [Sa, Sc]
-        kDst_Mode,      //!< [Da, Dc]
-        kSrcOver_Mode,  //!< [Sa + Da * (1 - Sa), Sc + Dc * (1 - Sa)]
-        kDstOver_Mode,  //!< [Da + Sa * (1 - Da), Dc + Sc * (1 - Da)]
-        kSrcIn_Mode,    //!< [Sa * Da, Sc * Da]
-        kDstIn_Mode,    //!< [Da * Sa, Dc * Sa]
-        kSrcOut_Mode,   //!< [Sa * (1 - Da), Sc * (1 - Da)]
-        kDstOut_Mode,   //!< [Da * (1 - Sa), Dc * (1 - Sa)]
-        kSrcATop_Mode,  //!< [Da, Sc * Da + Dc * (1 - Sa)]
-        kDstATop_Mode,  //!< [Sa, Dc * Sa + Sc * (1 - Da)]
-        kXor_Mode,      //!< [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + Dc * (1 - Sa)]
-        kPlus_Mode,     //!< [Sa + Da, Sc + Dc]
-        kModulate_Mode, // multiplies all components (= alpha and color)
-
-        // Following blend modes are defined in the CSS Compositing standard:
-        // https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blending
-        kScreen_Mode,
-        kLastCoeffMode = kScreen_Mode,
-
-        kOverlay_Mode,
-        kDarken_Mode,
-        kLighten_Mode,
-        kColorDodge_Mode,
-        kColorBurn_Mode,
-        kHardLight_Mode,
-        kSoftLight_Mode,
-        kDifference_Mode,
-        kExclusion_Mode,
-        kMultiply_Mode,
-        kLastSeparableMode = kMultiply_Mode,
-
-        kHue_Mode,
-        kSaturation_Mode,
-        kColor_Mode,
-        kLuminosity_Mode,
-        kLastMode = kLuminosity_Mode
-    };
-
-    /**
-     * Gets the name of the Mode as a string.
-     */
-    static const char* ModeName(Mode);
-    static const char* ModeName(SkBlendMode mode) {
-        return ModeName(Mode(mode));
-    }
+                        const SkAlpha aa[]) const = 0;
 
     /**
      *  If the xfermode is one of the modes in the Mode enum, then asMode()
      *  returns true and sets (if not null) mode accordingly. Otherwise it
      *  returns false and ignores the mode parameter.
      */
-    virtual bool asMode(Mode* mode) const;
-
-    /**
-     *  The same as calling xfermode->asMode(mode), except that this also checks
-     *  if the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
-     */
-    static bool AsMode(const SkXfermode*, Mode* mode);
-    static bool AsMode(const sk_sp<SkXfermode>& xfer, Mode* mode) {
-        return AsMode(xfer.get(), mode);
-    }
-
-    /**
-     *  Returns true if the xfermode claims to be the specified Mode. This works
-     *  correctly even if the xfermode is NULL (which equates to kSrcOver.) Thus
-     *  you can say this without checking for a null...
-     *
-     *  If (SkXfermode::IsMode(paint.getXfermode(),
-     *                         SkXfermode::kDstOver_Mode)) {
-     *      ...
-     *  }
-     */
-    static bool IsMode(const SkXfermode* xfer, Mode mode);
-    static bool IsMode(const sk_sp<SkXfermode>& xfer, Mode mode) {
-        return IsMode(xfer.get(), mode);
-    }
+    virtual bool asMode(SkBlendMode* mode) const;
 
     /** Return an SkXfermode object for the specified mode.
      */
     static sk_sp<SkXfermode> Make(SkBlendMode);
-    static sk_sp<SkXfermode> Make(Mode m) { return Make((SkBlendMode)m); }
 
     /**
      *  Skia maintains global xfermode objects corresponding to each BlendMode. This returns a
@@ -147,28 +66,14 @@ public:
     }
 
     SkBlendMode blend() const {
-        Mode mode;
+        SkBlendMode mode;
         SkAssertResult(this->asMode(&mode));
-        return (SkBlendMode)mode;
+        return mode;
     }
 
     static SkXfermodeProc GetProc(SkBlendMode);
     static SkXfermodeProc4f GetProc4f(SkBlendMode);
 
-    /**
-     * Returns whether or not the xfer mode can support treating coverage as alpha
-     */
-    virtual bool supportsCoverageAsAlpha() const;
-
-    /**
-     *  The same as calling xfermode->supportsCoverageAsAlpha(), except that this also checks if
-     *  the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
-     */
-    static bool SupportsCoverageAsAlpha(const SkXfermode* xfer);
-    static bool SupportsCoverageAsAlpha(const sk_sp<SkXfermode>& xfer) {
-        return SupportsCoverageAsAlpha(xfer.get());
-    }
-
     enum SrcColorOpacity {
         // The src color is known to be opaque (alpha == 255)
         kOpaque_SrcColorOpacity = 0,
@@ -180,21 +85,6 @@ public:
         kUnknown_SrcColorOpacity = 3
     };
 
-    /**
-     * Returns whether or not the result of the draw with the xfer mode will be opaque or not. The
-     * input to this call is an enum describing known information about the opacity of the src color
-     * that will be given to the xfer mode.
-     */
-    virtual bool isOpaque(SrcColorOpacity opacityType) const;
-
-    /**
-     *  The same as calling xfermode->isOpaque(...), except that this also checks if
-     *  the xfermode is NULL, and if so, treats it as kSrcOver_Mode.
-     */
-    static bool IsOpaque(const SkXfermode* xfer, SrcColorOpacity opacityType);
-    static bool IsOpaque(const sk_sp<SkXfermode>& xfer, SrcColorOpacity opacityType) {
-        return IsOpaque(xfer.get(), opacityType);
-    }
     static bool IsOpaque(SkBlendMode, SrcColorOpacity);
 
 #if SK_SUPPORT_GPU
@@ -249,20 +139,8 @@ public:
 
 protected:
     SkXfermode() {}
-    /** The default implementation of xfer32/xfer16/xferA8 in turn call this
-        method, 1 color at a time (upscaled to a SkPMColor). The default
-        implementation of this method just returns dst. If performance is
-        important, your subclass should override xfer32/xfer16/xferA8 directly.
-
-        This method will not be called directly by the client, so it need not
-        be implemented if your subclass has overridden xfer32/xfer16/xferA8
-    */
-    virtual SkPMColor xferColor(SkPMColor src, SkPMColor dst) const;
 
 private:
-    enum {
-        kModeCount = kLastMode + 1
-    };
 
     typedef SkFlattenable INHERITED;
 };
diff --git a/src/core/SkXfermode_proccoeff.h b/src/core/SkXfermode_proccoeff.h
index 6704a822ec..fdc36c6e86 100644
--- a/src/core/SkXfermode_proccoeff.h
+++ b/src/core/SkXfermode_proccoeff.h
@@ -8,8 +8,7 @@
 #ifndef SkXfermode_proccoeff_DEFINED
 #define SkXfermode_proccoeff_DEFINED
 
-#include "SkReadBuffer.h"
-#include "SkWriteBuffer.h"
+#include "SkXfermodePriv.h"
 
 struct ProcCoeff {
     SkXfermodeProc      fProc;
@@ -28,11 +27,7 @@ public:
     void xfer32(SkPMColor dst[], const SkPMColor src[], int count,
                 const SkAlpha aa[]) const override;
 
-    bool asMode(Mode* mode) const override;
-
-    bool supportsCoverageAsAlpha() const override;
-
-    bool isOpaque(SkXfermode::SrcColorOpacity opacityType) const override;
+    bool asMode(SkBlendMode* mode) const override;
 
 #if SK_SUPPORT_GPU
     sk_sp<GrFragmentProcessor> makeFragmentProcessorForImageFilter(
diff --git a/src/effects/SkArithmeticMode.cpp b/src/effects/SkArithmeticMode.cpp
index d604a12fbb..83b2100fe1 100644
--- a/src/effects/SkArithmeticMode.cpp
+++ b/src/effects/SkArithmeticMode.cpp
@@ -71,10 +71,10 @@ sk_sp<SkXfermode> SkArithmeticMode::Make(SkScalar k1, SkScalar k2, SkScalar k3,
                                          bool enforcePMColor) {
     if (SkScalarNearlyZero(k1) && SkScalarNearlyEqual(k2, SK_Scalar1) &&
         SkScalarNearlyZero(k3) && SkScalarNearlyZero(k4)) {
-        return SkXfermode::Make(SkXfermode::kSrc_Mode);
+        return SkXfermode::Make(SkBlendMode::kSrc);
     } else if (SkScalarNearlyZero(k1) && SkScalarNearlyZero(k2) &&
                SkScalarNearlyEqual(k3, SK_Scalar1) && SkScalarNearlyZero(k4)) {
-        return SkXfermode::Make(SkXfermode::kDst_Mode);
+        return SkXfermode::Make(SkBlendMode::kDst);
     }
     return sk_make_sp<SkArithmeticMode_scalar>(k1, k2, k3, k4, enforcePMColor);
 }
diff --git a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
index aa1c1c7c9d..8779c558cd 100644
--- a/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
+++ b/src/gpu/effects/GrXfermodeFragmentProcessor.cpp
@@ -211,7 +211,7 @@ void GLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) {
 
     // emit blend code
     SkBlendMode mode = cs.getMode();
-    fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkXfermode::ModeName(mode));
+    fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkBlendMode_Name(mode));
     GrGLSLBlend::AppendMode(fragBuilder,
                             srcColor.c_str(),
                             dstColor.c_str(),
@@ -426,7 +426,7 @@ public:
         }
 
         // emit blend code
-        fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkXfermode::ModeName(mode));
+        fragBuilder->codeAppendf("// Compose Xfer Mode: %s\n", SkBlendMode_Name(mode));
         const char* childStr = childColor.c_str();
         if (ComposeOneFragmentProcessor::kDst_Child == child) {
             GrGLSLBlend::AppendMode(fragBuilder, inputColor, childStr, args.fOutputColor, mode);
diff --git a/src/shaders/SkComposeShader.cpp b/src/shaders/SkComposeShader.cpp
index 4455f49931..135f91d362 100644
--- a/src/shaders/SkComposeShader.cpp
+++ b/src/shaders/SkComposeShader.cpp
@@ -150,7 +150,7 @@ void SkComposeShader::toString(SkString* str) const {
     str->append(" ShaderB: ");
     as_SB(fShaderB)->toString(str);
     if (SkBlendMode::kSrcOver != fMode) {
-        str->appendf(" Xfermode: %s", SkXfermode::ModeName(fMode));
+        str->appendf(" Xfermode: %s", SkBlendMode_Name(fMode));
     }
 
     this->INHERITED::toString(str);
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index fccf21156a..3c24c558ef 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -283,19 +283,6 @@ static void TestBitmapSerialization(const SkBitmap& validBitmap,
     }
 }
 
-static void TestXfermodeSerialization(skiatest::Reporter* reporter) {
-    for (size_t i = 0; i <= SkXfermode::kLastMode; ++i) {
-        if (i == SkXfermode::kSrcOver_Mode) {
-            // skip SrcOver, as it is allowed to return nullptr from Create()
-            continue;
-        }
-        auto mode(SkXfermode::Make(static_cast<SkXfermode::Mode>(i)));
-        REPORTER_ASSERT(reporter, mode);
-        sk_sp<SkXfermode> copy(
-            TestFlattenableSerialization<SkXfermode>(mode.get(), true, reporter));
-    }
-}
-
 static void TestColorFilterSerialization(skiatest::Reporter* reporter) {
     uint8_t table[256];
     for (int i = 0; i < 256; ++i) {
@@ -461,11 +448,6 @@ DEF_TEST(Serialization, reporter) {
         TestObjectSerialization(&region, reporter);
     }
 
-    // Test xfermode serialization
-    {
-        TestXfermodeSerialization(reporter);
-    }
-
     // Test color filter serialization
     {
         TestColorFilterSerialization(reporter);