Revert of Attach GrOptDrawState into shader building pipeline

Revert of Attach GrOptDrawState into shader building pipeline (patchset #11 id:220001 of https://codereview.chromium.org/504203004/)

Reason for revert:
Failing some msaa gm's

Original issue's description:
> Attach GrOptDrawState into shader building pipeline
> 
> The OptDrawState is now used for creating the actual gl shader. Current
> optimizations dones in GrOptDrawState include:
> All blend optimizations
> Constant color/coverage stage optimizations
> 
> BUG=skia:
> 
> Committed: https://skia.googlesource.com/skia/+/ee6206572b42fec11f83ad0c1e6d435903640518

TBR=bsalomon@google.com,joshualitt@google.com
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Committed: https://skia.googlesource.com/skia/+/8a4c1030ff4b8336b5ac5b0712691e2f65383440

[egdaniel, 2014-09-16 13:57:46]

Created Revert of Attach GrOptDrawState into shader building pipeline

[commit-bot: I haz the power, 2014-09-16 13:58:27]

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

[commit-bot: I haz the power, 2014-09-16 13:58:31]

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

[commit-bot: I haz the power, 2014-09-16 13:58:32]

Failed to apply patch for src/gpu/gl/GrGLProgramDesc.cpp:
While running git apply --index -p1;
  error: patch failed: src/gpu/gl/GrGLProgramDesc.cpp:11
  error: src/gpu/gl/GrGLProgramDesc.cpp: patch does not apply

Patch:       src/gpu/gl/GrGLProgramDesc.cpp
Index: src/gpu/gl/GrGLProgramDesc.cpp
diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp
index
bde4072cc3650b1bc2487bb4df30adcc1caf4901..d7ba287cfa623bc9050cd3b93ccdba686c5ff302
100644
--- a/src/gpu/gl/GrGLProgramDesc.cpp
+++ b/src/gpu/gl/GrGLProgramDesc.cpp
@@ -11,7 +11,6 @@
 #include "GrDrawEffect.h"
 #include "GrEffect.h"
 #include "GrGpuGL.h"
-#include "GrOptDrawState.h"
 
 #include "SkChecksum.h"
 
@@ -47,8 +46,9 @@
     return true;
 }
 
-bool GrGLProgramDesc::Build(const GrOptDrawState& optState,
+bool GrGLProgramDesc::Build(const GrDrawState& drawState,
                             GrGpu::DrawType drawType,
+                            GrDrawState::BlendOptFlags blendOpts,
                             GrBlendCoeff srcCoeff,
                             GrBlendCoeff dstCoeff,
                             const GrGpuGL* gpu,
@@ -60,19 +60,47 @@
     colorStages->reset();
     coverageStages->reset();
 
-    bool inputColorIsUsed = optState.inputColorIsUsed();
-    bool inputCoverageIsUsed = optState.inputColorIsUsed();
+    // This should already have been caught
+    SkASSERT(!(GrDrawState::kSkipDraw_BlendOptFlag & blendOpts));
+
+    bool skipCoverage = SkToBool(blendOpts &
GrDrawState::kEmitTransBlack_BlendOptFlag);
+
+    bool skipColor = SkToBool(blendOpts &
(GrDrawState::kEmitTransBlack_BlendOptFlag |
+                                          
GrDrawState::kEmitCoverage_BlendOptFlag));
+
+    int firstEffectiveColorStage = 0;
+    bool inputColorIsUsed = true;
+
+    if (!skipColor) {
+        firstEffectiveColorStage = drawState.numColorStages();
+        while (firstEffectiveColorStage > 0 && inputColorIsUsed) {
+            --firstEffectiveColorStage;
+            const GrEffect* effect =
drawState.getColorStage(firstEffectiveColorStage).getEffect();
+            inputColorIsUsed = effect->willUseInputColor();
+        }
+    }
+
+    int firstEffectiveCoverageStage = 0;
+    bool inputCoverageIsUsed = true;
+    if (!skipCoverage) {
+        firstEffectiveCoverageStage = drawState.numCoverageStages();
+        while (firstEffectiveCoverageStage > 0 && inputCoverageIsUsed) {
+            --firstEffectiveCoverageStage;
+            const GrEffect* effect =
drawState.getCoverageStage(firstEffectiveCoverageStage).getEffect();
+            inputCoverageIsUsed = effect->willUseInputColor();
+        }
+    }
 
     // The descriptor is used as a cache key. Thus when a field of the
     // descriptor will not affect program generation (because of the attribute
     // bindings in use or other descriptor field settings) it should be set
     // to a canonical value to avoid duplicate programs with different keys.
 
-    bool requiresColorAttrib = optState.hasColorVertexAttribute();
-    bool requiresCoverageAttrib = optState.hasCoverageVertexAttribute();
+    bool requiresColorAttrib = !skipColor &&
drawState.hasColorVertexAttribute();
+    bool requiresCoverageAttrib = !skipCoverage &&
drawState.hasCoverageVertexAttribute();
     // we only need the local coords if we're actually going to generate effect
code
-    bool requiresLocalCoordAttrib = optState.numTotalStages() > 0 &&
-                                    optState.hasLocalCoordAttribute();
+    bool requiresLocalCoordAttrib = !(skipCoverage  && skipColor) &&
+                                    drawState.hasLocalCoordAttribute();
 
     bool readsDst = false;
     bool readFragPosition = false;
@@ -80,8 +108,16 @@
     // Provide option for shader programs without vertex shader only when
drawing paths.
     bool requiresVertexShader = !GrGpu::IsPathRenderingDrawType(drawType);
 
-    int numStages = optState.numTotalStages();
-
+    int numStages = 0;
+    if (drawState.hasGeometryProcessor()) {
+        numStages++;
+    }
+    if (!skipColor) {
+        numStages += drawState.numColorStages() - firstEffectiveColorStage;
+    }
+    if (!skipCoverage) {
+        numStages += drawState.numCoverageStages() -
firstEffectiveCoverageStage;
+    }
     GR_STATIC_ASSERT(0 == kEffectKeyOffsetsAndLengthOffset % sizeof(uint32_t));
     // Make room for everything up to and including the array of offsets to
effect keys.
     desc->fKey.reset();
@@ -95,7 +131,7 @@
     memset(desc->header(), 0, kHeaderSize);
 
     // We can only have one effect which touches the vertex shader
-    if (optState.hasGeometryProcessor()) {
+    if (drawState.hasGeometryProcessor()) {
         uint16_t* offsetAndSize =
                 reinterpret_cast<uint16_t*>(desc->fKey.begin() +
kEffectKeyOffsetsAndLengthOffset +
                                             offsetAndSizeIndex * 2 *
sizeof(uint16_t));
@@ -104,7 +140,7 @@
             uint16_t effectKeySize;
             uint32_t effectOffset = desc->fKey.count();
             effectKeySuccess |= GetEffectKeyAndUpdateStats(
-                                    *optState.getGeometryProcessor(),
gpu->glCaps(),
+                                    *drawState.getGeometryProcessor(),
gpu->glCaps(),
                                     requiresLocalCoordAttrib, &b,
                                     &effectKeySize, &readsDst,
                                     &readFragPosition, &requiresVertexShader);
@@ -113,55 +149,57 @@
             offsetAndSize[0] = SkToU16(effectOffset);
             offsetAndSize[1] = effectKeySize;
             ++offsetAndSizeIndex;
-            *geometryProcessor = optState.getGeometryProcessor();
+            *geometryProcessor = drawState.getGeometryProcessor();
             SkASSERT(requiresVertexShader);
             header->fHasGeometryProcessor = true;
     }
 
-    for (int s = 0; s < optState.numColorStages(); ++s) {
-        uint16_t* offsetAndSize =
-            reinterpret_cast<uint16_t*>(desc->fKey.begin() +
kEffectKeyOffsetsAndLengthOffset +
-                                        offsetAndSizeIndex * 2 *
sizeof(uint16_t));
-
-        bool effectRequiresVertexShader = false;
-        GrEffectKeyBuilder b(&desc->fKey);
-        uint16_t effectKeySize;
-        uint32_t effectOffset = desc->fKey.count();
-        effectKeySuccess |= GetEffectKeyAndUpdateStats(
-            optState.getColorStage(s), gpu->glCaps(),
-            requiresLocalCoordAttrib, &b,
-            &effectKeySize, &readsDst,
-            &readFragPosition, &effectRequiresVertexShader);
-        effectKeySuccess |= (effectOffset <= SK_MaxU16);
-
-        offsetAndSize[0] = SkToU16(effectOffset);
-        offsetAndSize[1] = effectKeySize;
-        ++offsetAndSizeIndex;
-        SkASSERT(!effectRequiresVertexShader);
-    }
-
-    for (int s = 0; s < optState.numCoverageStages(); ++s) {
-        uint16_t* offsetAndSize =
-            reinterpret_cast<uint16_t*>(desc->fKey.begin() +
kEffectKeyOffsetsAndLengthOffset +
-                                        offsetAndSizeIndex * 2 *
sizeof(uint16_t));
-
-        bool effectRequiresVertexShader = false;
-        GrEffectKeyBuilder b(&desc->fKey);
-        uint16_t effectKeySize;
-        uint32_t effectOffset = desc->fKey.count();
-        effectKeySuccess |= GetEffectKeyAndUpdateStats(
-            optState.getCoverageStage(s), gpu->glCaps(),
-            requiresLocalCoordAttrib, &b,
-            &effectKeySize, &readsDst,
-            &readFragPosition, &effectRequiresVertexShader);
-        effectKeySuccess |= (effectOffset <= SK_MaxU16);
-
-        offsetAndSize[0] = SkToU16(effectOffset);
-        offsetAndSize[1] = effectKeySize;
-        ++offsetAndSizeIndex;
-        SkASSERT(!effectRequiresVertexShader);
-    }
-
+    if (!skipColor) {
+        for (int s = firstEffectiveColorStage; s < drawState.numColorStages();
++s) {
+            uint16_t* offsetAndSize =
+                reinterpret_cast<uint16_t*>(desc->fKey.begin() +
kEffectKeyOffsetsAndLengthOffset +
+                                            offsetAndSizeIndex * 2 *
sizeof(uint16_t));
+
+            bool effectRequiresVertexShader = false;
+            GrEffectKeyBuilder b(&desc->fKey);
+            uint16_t effectKeySize;
+            uint32_t effectOffset = desc->fKey.count();
+            effectKeySuccess |= GetEffectKeyAndUpdateStats(
+                                    drawState.getColorStage(s), gpu->glCaps(),
+                                    requiresLocalCoordAttrib, &b,
+                                    &effectKeySize, &readsDst,
+                                    &readFragPosition,
&effectRequiresVertexShader);
+            effectKeySuccess |= (effectOffset <= SK_MaxU16);
+
+            offsetAndSize[0] = SkToU16(effectOffset);
+            offsetAndSize[1] = effectKeySize;
+            ++offsetAndSizeIndex;
+            SkASSERT(!effectRequiresVertexShader);
+        }
+    }
+    if (!skipCoverage) {
+        for (int s = firstEffectiveCoverageStage; s <
drawState.numCoverageStages(); ++s) {
+            uint16_t* offsetAndSize =
+                reinterpret_cast<uint16_t*>(desc->fKey.begin() +
kEffectKeyOffsetsAndLengthOffset +
+                                            offsetAndSizeIndex * 2 *
sizeof(uint16_t));
+
+            bool effectRequiresVertexShader = false;
+            GrEffectKeyBuilder b(&desc->fKey);
+            uint16_t effectKeySize;
+            uint32_t effectOffset = desc->fKey.count();
+            effectKeySuccess |= GetEffectKeyAndUpdateStats(
+                                    drawState.getCoverageStage(s),
gpu->glCaps(),
+                                    requiresLocalCoordAttrib, &b,
+                                    &effectKeySize, &readsDst,
+                                    &readFragPosition,
&effectRequiresVertexShader);
+            effectKeySuccess |= (effectOffset <= SK_MaxU16);
+
+            offsetAndSize[0] = SkToU16(effectOf…
(message too large)

[egdaniel, 2014-09-16 14:17:56]

The CQ bit was checked by egdaniel@google.com

[commit-bot: I haz the power, 2014-09-16 14:18:44]

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

[commit-bot: I haz the power, 2014-09-16 14:18:58]

Committed patchset #1 (id:1) as 8a4c1030ff4b8336b5ac5b0712691e2f65383440