Revert of Implement Porter Duff XP with a blend table (patchset #12 id:220001 of https://codereview.chromium.org/1124373002/)

Reason for revert:
Blocking DEPS roll into Chromium. Crashing virtual/gpu/fast/canvas/canvas-composite-*.html tests with the assert

../../third_party/skia/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp:281: failed assertion "k110_GrGLSLGeneration != gpu->glslGeneration() || fOutputs.empty()"

Original issue's description:
> Implement Porter Duff XP with a blend table
>
> Removes the runtime logic used by PorterDuffXferProcessor to decide
> blend coeffs and shader outputs, and instead uses a compile-time
> constant table of pre-selected blend formulas.
>
> Introduces a new blend strategy for srcCoeff=0 that can apply coverage
> with a reverse subtract blend equation instead of dual source
> blending.
>
> Adds new macros in GrBlend.h to analyze blend formulas both runtime.
>
> Removes kSetCoverageDrawing_OptFlag and GrSimplifyBlend as they are no
> longer used.
>
> Adds a GM that verifies all xfermodes, including arithmetic, with the
> color/coverage invariants used by Porter Duff.
>
> Adds a unit test that verifies each Porter Duff formula with every
> color/coverage invariant.
>
> Major changes:
>
>  * Uses a reverse subtract blend equation for coverage when srcCoeff=0
>    (clear, dst-out [Sa=1], dst-in, modulate). Platforms that don't
>    support dual source blending no longer require a dst copy for
>    dst-in and modulate.
>
>  * Sets BlendInfo::fWriteColor to false when the blend does not modify
>    the dst. GrGLGpu will now use glColorMask instead of blending for
>    these modes (dst, dst-in [Sa=1], modulate ignored for [Sc=1]).
>
>  * Converts all SA blend coeffs to One for opaque inputs, and ISA to
>    Zero if there is also no coverage. (We keep ISA around when there
>    is coverage because we use it to tweak alpha for coverage.)
>
>  * Abandons solid white optimizations for the sake of simplicity
>    (screen was the only mode that previous had solid white opts).
>
> Minor differences:
>
>  * Inconsequential differences in opt flags (e.g. we now return
>    kCanTweakAlphaForCoverage_OptFlag even when there is no coverage).
>
>  * Src coeffs when the shader outputs 0.
>
>  * IS2C vs IS2A when the secondary output is scalar.
>
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/9a70920db22b6309c671f8e5d519bb95570e4414

TBR=egdaniel@google.com,bsalomon@google.com,cdalton@nvidia.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/1153993002

1 files changed, 8 insertions, 105 deletions

diff --git a/src/gpu/GrBlend.h b/src/gpu/GrBlend.h
index 05d7ebcfdc..e5b8993377 100644
--- a/src/gpu/GrBlend.h
+++ b/src/gpu/GrBlend.h
@@ -7,22 +7,13 @@
  */
 
 #include "GrTypes.h"
-#include "SkTLogic.h"
+#include "GrColor.h"
 #include "GrXferProcessor.h"
 
 #ifndef GrBlend_DEFINED
 #define GrBlend_DEFINED
 
-template<GrBlendCoeff Coeff>
-struct GrTBlendCoeffRefsSrc : SkTBool<kSC_GrBlendCoeff == Coeff ||
-                                      kISC_GrBlendCoeff == Coeff ||
-                                      kSA_GrBlendCoeff == Coeff ||
-                                      kISA_GrBlendCoeff == Coeff> {};
-
-#define GR_BLEND_COEFF_REFS_SRC(COEFF) \
-    GrTBlendCoeffRefsSrc<COEFF>::value
-
-inline bool GrBlendCoeffRefsSrc(GrBlendCoeff coeff) {
+static inline bool GrBlendCoeffRefsSrc(GrBlendCoeff coeff) {
     switch (coeff) {
         case kSC_GrBlendCoeff:
         case kISC_GrBlendCoeff:
@@ -34,17 +25,7 @@ inline bool GrBlendCoeffRefsSrc(GrBlendCoeff coeff) {
     }
 }
 
-
-template<GrBlendCoeff Coeff>
-struct GrTBlendCoeffRefsDst : SkTBool<kDC_GrBlendCoeff == Coeff ||
-                                      kIDC_GrBlendCoeff == Coeff ||
-                                      kDA_GrBlendCoeff == Coeff ||
-                                      kIDA_GrBlendCoeff == Coeff> {};
-
-#define GR_BLEND_COEFF_REFS_DST(COEFF) \
-    GrTBlendCoeffRefsDst<COEFF>::value
-
-inline bool GrBlendCoeffRefsDst(GrBlendCoeff coeff) {
+static inline bool GrBlendCoeffRefsDst(GrBlendCoeff coeff) {
     switch (coeff) {
         case kDC_GrBlendCoeff:
         case kIDC_GrBlendCoeff:
@@ -56,88 +37,10 @@ inline bool GrBlendCoeffRefsDst(GrBlendCoeff coeff) {
     }
 }
 
-
-template<GrBlendCoeff Coeff>
-struct GrTBlendCoeffRefsSrc2 : SkTBool<kS2C_GrBlendCoeff == Coeff ||
-                                       kIS2C_GrBlendCoeff == Coeff ||
-                                       kS2A_GrBlendCoeff == Coeff ||
-                                       kIS2A_GrBlendCoeff == Coeff> {};
-
-#define GR_BLEND_COEFF_REFS_SRC2(COEFF) \
-    GrTBlendCoeffRefsSrc2<COEFF>::value
-
-
-template<GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendCoeffsUseSrcColor : SkTBool<kZero_GrBlendCoeff != SrcCoeff ||
-                                           GR_BLEND_COEFF_REFS_SRC(DstCoeff)> {};
-
-#define GR_BLEND_COEFFS_USE_SRC_COLOR(SRC_COEFF, DST_COEFF) \
-    GrTBlendCoeffsUseSrcColor<SRC_COEFF, DST_COEFF>::value
-
-
-template<GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendCoeffsUseDstColor : SkTBool<GR_BLEND_COEFF_REFS_DST(SrcCoeff) ||
-                                           kZero_GrBlendCoeff != DstCoeff> {};
-
-#define GR_BLEND_COEFFS_USE_DST_COLOR(SRC_COEFF, DST_COEFF) \
-    GrTBlendCoeffsUseDstColor<SRC_COEFF, DST_COEFF>::value
-
-
-template<GrBlendEquation Equation>
-struct GrTBlendEquationIsAdvanced : SkTBool<Equation >= kFirstAdvancedGrBlendEquation> {};
-
-#define GR_BLEND_EQUATION_IS_ADVANCED(EQUATION) \
-    GrTBlendEquationIsAdvanced<EQUATION>::value
-
-inline bool GrBlendEquationIsAdvanced(GrBlendEquation equation) {
-    return equation >= kFirstAdvancedGrBlendEquation;
-}
-
-
-template<GrBlendEquation BlendEquation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendModifiesDst : SkTBool<(kAdd_GrBlendEquation != BlendEquation &&
-                                      kReverseSubtract_GrBlendEquation != BlendEquation) ||
-                                     kZero_GrBlendCoeff != SrcCoeff ||
-                                     kOne_GrBlendCoeff != DstCoeff> {};
-
-#define GR_BLEND_MODIFIES_DST(EQUATION, SRC_COEFF, DST_COEFF) \
-    GrTBlendModifiesDst<EQUATION, SRC_COEFF, DST_COEFF>::value
-
-
-/**
- * Advanced blend equations can always tweak alpha for coverage. (See GrCustomXfermode.cpp)
- *
- * For "add" and "reverse subtract" the blend equation with f=coverage is:
- *
- *   D' = f * (S * srcCoeff + D * dstCoeff) + (1-f) * D
- *      = f * S * srcCoeff + D * (f * dstCoeff + (1 - f))
- *
- * (Let srcCoeff be negative for reverse subtract.) We can tweak alpha for coverage when the
- * following relationship holds:
- *
- *   (f*S) * srcCoeff' + D * dstCoeff' == f * S * srcCoeff + D * (f * dstCoeff + (1 - f))
- *
- * (Where srcCoeff' and dstCoeff' have any reference to S pre-multiplied by f.)
- *
- * It's easy to see this works for the src term as long as srcCoeff' == srcCoeff (meaning srcCoeff
- * does not reference S). For the dst term, this will work as long as the following is true:
- *|
- *   dstCoeff' == f * dstCoeff + (1 - f)
- *   dstCoeff' == 1 - f * (1 - dstCoeff)
- *
- * By inspection we can see this will work as long as dstCoeff has a 1, and any other term in
- * dstCoeff references S.
- */
-template<GrBlendEquation Equation, GrBlendCoeff SrcCoeff, GrBlendCoeff DstCoeff>
-struct GrTBlendCanTweakAlphaForCoverage : SkTBool<GR_BLEND_EQUATION_IS_ADVANCED(Equation) ||
-                                                  ((kAdd_GrBlendEquation == Equation ||
-                                                    kReverseSubtract_GrBlendEquation == Equation) &&
-                                                   !GR_BLEND_COEFF_REFS_SRC(SrcCoeff) &&
-                                                   (kOne_GrBlendCoeff == DstCoeff ||
-                                                    kISC_GrBlendCoeff == DstCoeff ||
-                                                    kISA_GrBlendCoeff == DstCoeff))> {};
-
-#define GR_BLEND_CAN_TWEAK_ALPHA_FOR_COVERAGE(EQUATION, SRC_COEFF, DST_COEFF) \
-    GrTBlendCanTweakAlphaForCoverage<EQUATION, SRC_COEFF, DST_COEFF>::value
+GrColor GrSimplifyBlend(GrBlendCoeff* srcCoeff,
+                        GrBlendCoeff* dstCoeff,
+                        GrColor srcColor, uint32_t srcCompFlags,
+                        GrColor dstColor, uint32_t dstCompFlags,
+                        GrColor constantColor);
 
 #endif