Revert of Implement Porter Duff XP with a blend table

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:

Committed: https://skia.googlesource.com/skia/+/c33db93d1b285923b5deef97ecb04d4d01e05dd5

[bungeman-skia, 2015-05-23 00:43:33]

Created Revert of Implement Porter Duff XP with a blend table

[commit-bot: I haz the power, 2015-05-23 00:43:41]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1153993002/1

[commit-bot: I haz the power, 2015-05-23 00:43:50]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2015-05-23 00:43:53]

Failed to apply patch for src/gpu/effects/GrPorterDuffXferProcessor.cpp:
While running git apply --index -3 -p1;
  <stdin>:410: trailing whitespace.
              fPrimaryOutputType != xp.fPrimaryOutputType || 
  <stdin>:627: trailing whitespace.
      , fPrimaryOutputType(kModulate_PrimaryOutputType) 
  error: patch failed: src/gpu/effects/GrPorterDuffXferProcessor.cpp:744
  error: repository lacks the necessary blob to fall back on 3-way merge.
  error: src/gpu/effects/GrPorterDuffXferProcessor.cpp: patch does not apply

Patch:       src/gpu/effects/GrPorterDuffXferProcessor.cpp
Index: src/gpu/effects/GrPorterDuffXferProcessor.cpp
diff --git a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
index
0110b2982da450cd66212b2f3ff972e0a196877d..424fbbf36b5053f5e06045614fbc6ff06d3582b3
100644
--- a/src/gpu/effects/GrPorterDuffXferProcessor.cpp
+++ b/src/gpu/effects/GrPorterDuffXferProcessor.cpp
@@ -17,299 +17,28 @@
 #include "gl/builders/GrGLFragmentShaderBuilder.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
-/**
- * Wraps the shader outputs and HW blend state that comprise a Porter Duff
blend mode with coverage.
- */
-struct BlendFormula {
-public:
-    /**
-     * Values the shader can write to primary and secondary outputs. These must
all be modulated by
-     * coverage to support mixed samples. The XP will ignore the multiplies
when not using coverage.
+static bool can_tweak_alpha_for_coverage(GrBlendCoeff dstCoeff) {
+    /*
+     The fractional coverage is f.
+     The src and dst coeffs are Cs and Cd.
+     The dst and src colors are S and D.
+     We want the blend to compute: f*Cs*S + (f*Cd + (1-f))D. By tweaking the
source color's alpha
+     we're replacing S with S'=fS. It's obvious that that first term will
always be ok. The second
+     term can be rearranged as [1-(1-Cd)f]D. By substituting in the various
possibilities for Cd we
+     find that only 1, ISA, and ISC produce the correct destination when
applied to S' and D.
      */
-    enum OutputType {
-        kNone_OutputType,        //<! 0
-        kCoverage_OutputType,    //<! inputCoverage
-        kModulate_OutputType,    //<! inputColor * inputCoverage
-        kISAModulate_OutputType, //<! (1 - inputColor.a) * inputCoverage
-        kISCModulate_OutputType, //<! (1 - inputColor) * inputCoverage
-
-        kLast_OutputType = kISCModulate_OutputType
-    };
-
-    enum Properties {
-        kModifiesDst_Property              = 1,
-        kUsesDstColor_Property             = 1 << 1,
-        kUsesInputColor_Property           = 1 << 2,
-        kCanTweakAlphaForCoverage_Property = 1 << 3,
-
-        kLast_Property = kCanTweakAlphaForCoverage_Property
-    };
-
-    BlendFormula& operator =(const BlendFormula& other) {
-        fData = other.fData;
-        return *this;
-    }
-
-    bool operator ==(const BlendFormula& other) const {
-        return fData == other.fData;
-    }
-
-    bool hasSecondaryOutput() const { return kNone_OutputType !=
fSecondaryOutputType; }
-    bool modifiesDst() const { return SkToBool(fProps & kModifiesDst_Property);
}
-    bool usesDstColor() const { return SkToBool(fProps &
kUsesDstColor_Property); }
-    bool usesInputColor() const { return SkToBool(fProps &
kUsesInputColor_Property); }
-    bool canTweakAlphaForCoverage() const {
-        return SkToBool(fProps & kCanTweakAlphaForCoverage_Property);
-    }
-
-    /**
-     * Deduce the properties of a compile-time constant BlendFormula.
-     */
-    template<OutputType PrimaryOut, OutputType SecondaryOut,
-             GrBlendEquation BlendEquation, GrBlendCoeff SrcCoeff, GrBlendCoeff
DstCoeff>
-    struct get_properties : SkTIntegralConstant<Properties,
static_cast<Properties>(
-
-        (GR_BLEND_MODIFIES_DST(BlendEquation, SrcCoeff, DstCoeff) ?
-            kModifiesDst_Property : 0) |
-
-        (GR_BLEND_COEFFS_USE_DST_COLOR(SrcCoeff, DstCoeff) ?
-            kUsesDstColor_Property : 0) |
-
-        ((PrimaryOut >= kModulate_OutputType &&
GR_BLEND_COEFFS_USE_SRC_COLOR(SrcCoeff,DstCoeff)) ||
-         (SecondaryOut >= kModulate_OutputType &&
GR_BLEND_COEFF_REFS_SRC2(DstCoeff)) ?
-            kUsesInputColor_Property : 0) |  // We assert later that SrcCoeff
doesn't ref src2.
-
-        (kModulate_OutputType == PrimaryOut &&
-         kNone_OutputType == SecondaryOut &&
-         GR_BLEND_CAN_TWEAK_ALPHA_FOR_COVERAGE(BlendEquation, SrcCoeff,
DstCoeff) ?
-            kCanTweakAlphaForCoverage_Property : 0))> {
-
-        // The provided formula should already be optimized.
-        GR_STATIC_ASSERT((kNone_OutputType == PrimaryOut) ==
-                         !GR_BLEND_COEFFS_USE_SRC_COLOR(SrcCoeff, DstCoeff));
-        GR_STATIC_ASSERT(!GR_BLEND_COEFF_REFS_SRC2(SrcCoeff));
-        GR_STATIC_ASSERT((kNone_OutputType == SecondaryOut) ==
-                         !GR_BLEND_COEFF_REFS_SRC2(DstCoeff));
-        GR_STATIC_ASSERT(PrimaryOut != SecondaryOut || kNone_OutputType ==
PrimaryOut);
-        GR_STATIC_ASSERT(kNone_OutputType != PrimaryOut || kNone_OutputType ==
SecondaryOut);
-    };
-
-    union {
-        struct {
-            // We allot the enums one more bit than they require because MSVC
seems to sign-extend
-            // them when the top bit is set. (This is in violation of the C++03
standard 9.6/4)
-            OutputType        fPrimaryOutputType    : 4;
-            OutputType        fSecondaryOutputType  : 4;
-            GrBlendEquation   fBlendEquation        : 6;
-            GrBlendCoeff      fSrcCoeff             : 6;
-            GrBlendCoeff      fDstCoeff             : 6;
-            Properties        fProps                : 32 - (4 + 4 + 6 + 6 + 6);
-        };
-        uint32_t fData;
-    };
-
-    GR_STATIC_ASSERT(kLast_OutputType      < (1 << 3));
-    GR_STATIC_ASSERT(kLast_GrBlendEquation < (1 << 5));
-    GR_STATIC_ASSERT(kLast_GrBlendCoeff    < (1 << 5));
-    GR_STATIC_ASSERT(kLast_Property        < (1 << 6));
-};
-
-GR_STATIC_ASSERT(4 == sizeof(BlendFormula));
-
-GR_MAKE_BITFIELD_OPS(BlendFormula::Properties);
-
-/**
- * Initialize a compile-time constant BlendFormula and automatically deduce
fProps.
- */
-#define INIT_BLEND_FORMULA(PRIMARY_OUT, SECONDARY_OUT, BLEND_EQUATION,
SRC_COEFF, DST_COEFF) \
-    {{{PRIMARY_OUT, \
-       SECONDARY_OUT, \
-       BLEND_EQUATION, SRC_COEFF, DST_COEFF, \
-       BlendFormula::get_properties<PRIMARY_OUT, SECONDARY_OUT, \
-                                    BLEND_EQUATION, SRC_COEFF,
DST_COEFF>::value}}}
-
-/**
- * When there is no coverage, or the blend mode can tweak alpha for coverage,
we use the standard
- * Porter Duff formula.
- */
-#define COEFF_FORMULA(SRC_COEFF, DST_COEFF) \
-    INIT_BLEND_FORMULA(BlendFormula::kModulate_OutputType, \
-                       BlendFormula::kNone_OutputType, \
-                       kAdd_GrBlendEquation, SRC_COEFF, DST_COEFF)
-
-/**
- * When the coeffs are (Zero, Zero), we clear the dst. This formula has its own
macro so we can set
- * the primary output type to none.
- */
-#define DST_CLEAR_FORMULA \
-    INIT_BLEND_FORMULA(BlendFormula::kNone_OutputType, \
-                       BlendFormula::kNone_OutputType, \
-                       kAdd_GrBlendEquation, kZero_GrBlendCoeff,
kZero_GrBlendCoeff)
-
-/**
- * When the coeffs are (Zero, One), we don't write to the dst at all. This
formula has its own macro
- * so we can set the primary output type to none.
- */
-#define NO_DST_WRITE_FORMULA \
-    INIT_BLEND_FORMULA(BlendFormula::kNone_OutputType, \
-                       BlendFormula::kNone_OutputType, \
-                       kAdd_GrBlendEquation, kZero_GrBlendCoeff,
kOne_GrBlendCoeff)
-
-/**
- * When there is coverage, the equation with f=coverage is:
- *
- *   D' = f * (S * srcCoeff + D * dstCoeff) + (1-f) * D
- *
- * This can be rewritten as:
- *
- *   D' = f * S * srcCoeff + D * (1 - [f * (1 - dstCoeff)])
- *
- * To implement this formula, we output [f * (1 - dstCoeff)] for the secondary
color and replace the
- * HW dst coeff with IS2C.
- *
- * Xfer modes: dst-atop (Sa!=1)
- */
-#define COVERAGE_FORMULA(ONE_MINUS_DST_COEFF_MODULATE_OUTPUT, SRC_COEFF) \
-    INIT_BLEND_FORMULA(BlendFormula::kModulate_OutputType, \
-                       ONE_MINUS_DST_COEFF_MODULATE_OUTPUT, \
-                       kAdd_GrBlendEquation, SRC_COEFF, kIS2C_GrBlendCoeff)
-
-/**
- * When there is coverage and the src coeff is Zero, the equation with
f=coverage becomes:
- *
- *   D' = f * D * dstCoeff + (1-f) * D
- *
- * This can be rewritten as:
- *
- *   D' = D - D * [f * (1 - dstCoeff)]
- *
- * To implement this formula, we output [f * (1 - dstCoeff)] for the primary
color and use a reverse
- * subtract HW blend equation with coeffs of (DC, One).
- *
- * Xfer modes: clear, dst-out (Sa=1), dst-in (Sa!=1), modulate (Sc!=1)
- */
-#define COVERAGE_SRC_COEFF_ZERO_FORMULA(ONE_MINUS_DST_COEFF_MODULATE_OUTPUT) \
-    INIT_BLEND_FORMULA(ONE_MINUS_DST_COEFF_MODULATE_OUTPUT, \
-                       BlendFormula::kNone_OutputType, \
-                       kReverseSubtract_GrBlendEquation, kDC_GrBlendCoeff,
kOne_GrBlendCoeff)
-
-/**
- * When there is coverage and the dst coeff is Zero, the equation with
f=coverage becomes:
- *
- *   D' = f * S * srcCoeff + (1-f) * D
- *
- * To implement this formula, we output [f] for the secondary color and replace
the HW dst coeff
- * with IS2A. (Note that we can avoid dual source blending when Sa=1 by using
ISA.)
- *
- * Xfer modes (Sa!=1): src, src-in, src-out
- */
-#define COVERAGE_DST_COEFF_ZERO_FORMULA(SRC_COEFF) \
-    INIT_BLEND_FORMULA(BlendFormula::kModulate_OutputType, \
-                       BlendFormula::kCoverage_OutputType, \
-                       kAdd_GrBlendEquation, SRC_COEFF, kIS2A_GrBlendCoeff)
-
-/**
- * This table outlines the blend formulas we will use with each xfermode, with
and without coverage,
- * with and without an opaque input color. Optimization properties are deduced
at compile time so we
- * can make runtime decision…
(message too large)

[bungeman-skia, 2015-05-23 00:55:12]

The CQ bit was checked by bungeman@google.com

[commit-bot: I haz the power, 2015-05-23 00:55:21]

CQ is trying da patch. Follow status at
 https://chromium-cq-status.appspot.com/patch-status/1153993002/1

[commit-bot: I haz the power, 2015-05-23 00:55:30]

Committed patchset #1 (id:1) as
https://skia.googlesource.com/skia/+/c33db93d1b285923b5deef97ecb04d4d01e05dd5

[bungeman-skia, 2015-05-23 00:58:03]

On 2015/05/23 00:55:30, I haz the power - commit-bot wrote:
> Committed patchset #1 (id:1) as
> https://skia.googlesource.com/skia/+/c33db93d1b285923b5deef97ecb04d4d01e05dd5

See roll at https://codereview.chromium.org/1152203005/ vs
https://codereview.chromium.org/1159453003/ , the bots to check are
linux_blink_rel . A failed build can be found at
http://build.chromium.org/p/tryserver.blink/builders/linux_blink_rel/builds/6...
.

[reed2, 2015-05-23 16:46:04]

reed@chromium.org changed reviewers:
+ reed@chromium.org

[reed2, 2015-05-23 16:46:04]

Ben, the roller seems funny. I tried to stop and restart it, but only succeeded
in stopping it ... oops.