Make GrGLProgramDesc's key variable length by compacting the effect key array

src/gpu/gl/GrGLProgram.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLProgram.h"
 
 #include "GrAllocator.h"
@@ skipping 78 matching lines @@
 
 void GrGLProgram::abandon() {
     fVShaderID = 0;
     fGShaderID = 0;
     fFShaderID = 0;
     fProgramID = 0;
 }
 
 void GrGLProgram::overrideBlend(GrBlendCoeff* srcCoeff,
                                 GrBlendCoeff* dstCoeff) const {
-    switch (fDesc.fCoverageOutput) {
+    switch (fDesc.getHeader().fCoverageOutput) {
         case GrGLProgramDesc::kModulate_CoverageOutput:
             break;
         // The prog will write a coverage value to the secondary
         // output and the dst is blended by one minus that value.
         case GrGLProgramDesc::kSecondaryCoverage_CoverageOutput:
         case GrGLProgramDesc::kSecondaryCoverageISA_CoverageOutput:
         case GrGLProgramDesc::kSecondaryCoverageISC_CoverageOutput:
             *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             break;
         case GrGLProgramDesc::kCombineWithDst_CoverageOutput:
@@ skipping 104 matching lines @@
     blend_term_string(&colorStr, colorCoeff, filterColor, inColor, inColor);
     blend_term_string(&constStr, uniformCoeff, filterColor, inColor, filterColor);
 
     SkString sum;
     GrGLSLAddf<4>(&sum, colorStr.c_str(), constStr.c_str());
     builder->fsCodeAppendf("\t%s = %s;\n", outputVar, sum.c_str());
 }
 }
 
 GrSLConstantVec GrGLProgram::genInputColor(GrGLShaderBuilder* builder, SkString* inColor) {
-    switch (fDesc.fColorInput) {
+    switch (fDesc.getHeader().fColorInput) {
         case GrGLProgramDesc::kAttribute_ColorInput: {
             builder->addAttribute(kVec4f_GrSLType, COL_ATTR_NAME);
             const char *vsName, *fsName;
             builder->addVarying(kVec4f_GrSLType, "Color", &vsName, &fsName);
             builder->vsCodeAppendf("\t%s = " COL_ATTR_NAME ";\n", vsName);
             *inColor = fsName;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kUniform_ColorInput: {
             const char* name;
             fUniformHandles.fColorUni = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                             kVec4f_GrSLType, "Color", &name);
             *inColor = name;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kTransBlack_ColorInput:
             inColor->reset();
             return kZeros_GrSLConstantVec;
         case GrGLProgramDesc::kSolidWhite_ColorInput:
             inColor->reset();
             return kOnes_GrSLConstantVec;
         default:
             GrCrash("Unknown color type.");
             return kNone_GrSLConstantVec;
     }
 }
 
 GrSLConstantVec GrGLProgram::genInputCoverage(GrGLShaderBuilder* builder, SkString* inCoverage) {
-    switch (fDesc.fCoverageInput) {
+    switch (fDesc.getHeader().fCoverageInput) {
         case GrGLProgramDesc::kAttribute_ColorInput: {
             builder->addAttribute(kVec4f_GrSLType, COV_ATTR_NAME);
             const char *vsName, *fsName;
             builder->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
             builder->vsCodeAppendf("\t%s = " COV_ATTR_NAME ";\n", vsName);
             *inCoverage = fsName;
             return kNone_GrSLConstantVec;
         }
         case GrGLProgramDesc::kUniform_ColorInput: {
             const char* name;
@@ skipping 11 matching lines @@
             return kOnes_GrSLConstantVec;
         default:
             GrCrash("Unknown color type.");
             return kNone_GrSLConstantVec;
     }
 }
 
 void GrGLProgram::genGeometryShader(GrGLShaderBuilder* builder) const {
 #if GR_GL_EXPERIMENTAL_GS
     // TODO: The builder should add all this glue code.
-    if (fDesc.fExperimentalGS) {
+    if (fDesc.getHeader().fExperimentalGS) {
         GrAssert(fContext.info().glslGeneration() >= k150_GrGLSLGeneration);
         builder->fGSHeader.append("layout(triangles) in;\n"
                                    "layout(triangle_strip, max_vertices = 6) out;\n");
         builder->gsCodeAppend("\tfor (int i = 0; i < 3; ++i) {\n"
                               "\t\tgl_Position = gl_in[i].gl_Position;\n");
-        if (fDesc.fEmitsPointSize) {
+        if (fDesc.getHeader().fEmitsPointSize) {
             builder->gsCodeAppend("\t\tgl_PointSize = 1.0;\n");
         }
         GrAssert(builder->fGSInputs.count() == builder->fGSOutputs.count());
         int count = builder->fGSInputs.count();
         for (int i = 0; i < count; ++i) {
             builder->gsCodeAppendf("\t\t%s = %s[i];\n",
                                    builder->fGSOutputs[i].getName().c_str(),
                                    builder->fGSInputs[i].getName().c_str());
         }
         builder->gsCodeAppend("\t\tEmitVertex();\n"
                               "\t}\n"
                               "\tEndPrimitive();\n");
     }
 #endif
 }
 
 const char* GrGLProgram::adjustInColor(const SkString& inColor) const {
     if (inColor.size()) {
           return inColor.c_str();
     } else {
-        if (GrGLProgramDesc::kSolidWhite_ColorInput == fDesc.fColorInput) {
+        if (GrGLProgramDesc::kSolidWhite_ColorInput == fDesc.getHeader().fColorInput) {
             return GrGLSLOnesVecf(4);
         } else {
             return GrGLSLZerosVecf(4);
         }
     }
 }
 
 namespace {
 // prints a shader using params similar to glShaderSource
 void print_shader(GrGLint stringCnt,
@@ skipping 82 matching lines @@
         GrPrintf(shader.c_str());
         GrPrintf("\n");
     }
 
     if (!(fVShaderID = compile_shader(fContext, GR_GL_VERTEX_SHADER, shader))) {
         return false;
     }
 
     fGShaderID = 0;
 #if GR_GL_EXPERIMENTAL_GS
-    if (fDesc.fExperimentalGS) {
+    if (fDesc.getHeader().fExperimentalGS) {
         builder.getShader(GrGLShaderBuilder::kGeometry_ShaderType, &shader);
         if (c_PrintShaders) {
             GrPrintf(shader.c_str());
             GrPrintf("\n");
         }
         if (!(fGShaderID = compile_shader(fContext, GR_GL_GEOMETRY_SHADER, shader))) {
             return false;
         }
     }
 #endif
 
     builder.getShader(GrGLShaderBuilder::kFragment_ShaderType, &shader);
     if (c_PrintShaders) {
         GrPrintf(shader.c_str());
         GrPrintf("\n");
     }
     if (!(fFShaderID = compile_shader(fContext, GR_GL_FRAGMENT_SHADER, shader))) {
         return false;
     }
 
     return true;
 }
 
 bool GrGLProgram::genProgram(const GrEffectStage* stages[]) {
     GrAssert(0 == fProgramID);
 
+    const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
+
     GrGLShaderBuilder builder(fContext.info(), fUniformManager, fDesc);
 
     // the dual source output has no canonical var name, have to
     // declare an output, which is incompatible with gl_FragColor/gl_FragData.
     bool dualSourceOutputWritten = false;
 
     GrGLShaderVar colorOutput;
     bool isColorDeclared = GrGLSLSetupFSColorOuput(fContext.info().glslGeneration(),
                                                    declared_color_output_name(),
                                                    &colorOutput);
     if (isColorDeclared) {
         builder.fFSOutputs.push_back(colorOutput);
     }
 
     const char* viewMName;
     fUniformHandles.fViewMatrixUni = builder.addUniform(GrGLShaderBuilder::kVertex_ShaderType,
                                                         kMat33f_GrSLType, "ViewM", &viewMName);
 
 
     builder.vsCodeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n"
                           "\tgl_Position = vec4(pos3.xy, 0, pos3.z);\n",
                           viewMName, builder.positionAttribute().getName().c_str());
 
     // incoming color to current stage being processed.
     SkString inColor;
     GrSLConstantVec knownColorValue = this->genInputColor(&builder, &inColor);
 
     // we output point size in the GS if present
-    if (fDesc.fEmitsPointSize
+    if (header.fEmitsPointSize
 #if GR_GL_EXPERIMENTAL_GS
-        && !fDesc.fExperimentalGS
+        && !header.fExperimentalGS
 #endif
         ) {
         builder.vsCodeAppend("\tgl_PointSize = 1.0;\n");
     }
 
     // Get the coeffs for the Mode-based color filter, determine if color is needed.
     SkXfermode::Coeff colorCoeff;
     SkXfermode::Coeff filterColorCoeff;
     SkAssertResult(
-        SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>(fDesc.fColorFilterXfermode),
+        SkXfermode::ModeAsCoeff(static_cast<SkXfermode::Mode>(header.fColorFilterXfermode),
                                 &filterColorCoeff,
                                 &colorCoeff));
     bool needColor, needFilterColor;
     need_blend_inputs(filterColorCoeff, colorCoeff, &needFilterColor, &needColor);
 
     // used in order for builder to return the per-stage uniform handles.
     SkTArray<GrGLUniformManager::UniformHandle, true>* stageUniformArrays[GrDrawState::kNumStages];
 
     if (needColor) {
-        for (int s = 0; s < fDesc.fFirstCoverageStage; ++s) {
+        for (int s = 0; s < fDesc.numColorEffects(); ++s) {
             stageUniformArrays[s] = &fUniformHandles.fEffectSamplerUnis[s];
         }
 
         builder.emitEffects(stages,
-                            fDesc.fEffectKeys,
-                            fDesc.fFirstCoverageStage,
+                            fDesc.effectKeys(),
+                            fDesc.numColorEffects(),
                             &inColor,
                             &knownColorValue,
                             stageUniformArrays,
                             fEffects);
     }
 
     // Insert the color filter. This will soon be replaced by a color effect.
-    if (SkXfermode::kDst_Mode != fDesc.fColorFilterXfermode) {
+    if (SkXfermode::kDst_Mode != header.fColorFilterXfermode) {
         const char* colorFilterColorUniName = NULL;
         fUniformHandles.fColorFilterUni = builder.addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                              kVec4f_GrSLType, "FilterColor",
                                                              &colorFilterColorUniName);
 
         builder.fsCodeAppend("\tvec4 filteredColor;\n");
         const char* color;
         // add_color_filter requires a real input string.
         if (knownColorValue == kOnes_GrSLConstantVec) {
             color = GrGLSLOnesVecf(4);
         } else if (knownColorValue == kZeros_GrSLConstantVec) {
             color = GrGLSLZerosVecf(4);
         } else {
             color = inColor.c_str();
         }
         add_color_filter(&builder, "filteredColor", filterColorCoeff,
                          colorCoeff, colorFilterColorUniName, color);
         inColor = "filteredColor";
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // compute the partial coverage
     SkString inCoverage;
     GrSLConstantVec knownCoverageValue = this->genInputCoverage(&builder, &inCoverage);
 
-    for (int s = fDesc.fFirstCoverageStage, i = 0; s < GrDrawState::kNumStages; ++s, ++i) {
-        stageUniformArrays[i] = &fUniformHandles.fEffectSamplerUnis[s];
+    for (int s = 0; s < fDesc.numCoverageEffects(); ++s) {
+        stageUniformArrays[s] = &fUniformHandles.fEffectSamplerUnis[s + fDesc.numColorEffects()];
     }
 
-    builder.emitEffects(stages + fDesc.fFirstCoverageStage,
-                        fDesc.fEffectKeys + fDesc.fFirstCoverageStage,
-                        GrDrawState::kNumStages - fDesc.fFirstCoverageStage,
+    builder.emitEffects(stages + fDesc.numColorEffects(),
+                        fDesc.getEffectKeys() + fDesc.numColorEffects(),
+                        fDesc.numCoverageEffects(),
                         &inCoverage,
                         &knownCoverageValue,
                         stageUniformArrays,
-                        fEffects + fDesc.fFirstCoverageStage);
+                        fEffects + fDesc.numColorEffects());
 
     // discard if coverage is zero
-    if (fDesc.fDiscardIfZeroCoverage && kOnes_GrSLConstantVec != knownCoverageValue) {
+    if (header.fDiscardIfZeroCoverage && kOnes_GrSLConstantVec != knownCoverageValue) {
         if (kZeros_GrSLConstantVec == knownCoverageValue) {
             // This is unfortunate.
             builder.fsCodeAppend("\tdiscard;\n");
         } else {
             builder.fsCodeAppendf("\tif (all(lessThanEqual(%s, vec4(0.0)))) {\n\t\tdiscard;\n\t}\n",
                                   inCoverage.c_str());
         }
     }
 
     GrGLProgramDesc::CoverageOutput coverageOutput =
-        static_cast<GrGLProgramDesc::CoverageOutput>(fDesc.fCoverageOutput);
+        static_cast<GrGLProgramDesc::CoverageOutput>(header.fCoverageOutput);
     if (GrGLProgramDesc::CoverageOutputUsesSecondaryOutput(coverageOutput)) {
         builder.fFSOutputs.push_back().set(kVec4f_GrSLType,
                                            GrGLShaderVar::kOut_TypeModifier,
                                            dual_source_output_name());
         // default coeff to ones for kCoverage_DualSrcOutput
         SkString coeff;
         GrSLConstantVec knownCoeffValue = kOnes_GrSLConstantVec;
-        if (GrGLProgramDesc::kSecondaryCoverageISA_CoverageOutput == fDesc.fCoverageOutput) {
+        if (GrGLProgramDesc::kSecondaryCoverageISA_CoverageOutput == header.fCoverageOutput) {
             // Get (1-A) into coeff
             SkString inColorAlpha;
             GrGLSLGetComponent4f(&inColorAlpha,
                                     inColor.c_str(),
                                     kA_GrColorComponentFlag,
                                     knownColorValue,
                                     true);
             knownCoeffValue = GrGLSLSubtractf<1>(&coeff,
                                                  NULL,
                                                  inColorAlpha.c_str(),
@@ skipping 105 matching lines @@
     }
     GL_CALL(AttachShader(fProgramID, fFShaderID));
 
     if (bindColorOut) {
         GL_CALL(BindFragDataLocation(fProgramID, 0, declared_color_output_name()));
     }
     if (bindDualSrcOut) {
         GL_CALL(BindFragDataLocationIndexed(fProgramID, 0, 1, dual_source_output_name()));
     }
 
+    const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
+
     // Bind the attrib locations to same values for all shaders
     GL_CALL(BindAttribLocation(fProgramID,
-                               fDesc.fPositionAttributeIndex,
+                               header.fPositionAttributeIndex,
                                builder.positionAttribute().c_str()));
-    if (-1 != fDesc.fLocalCoordAttributeIndex) {
+    if (-1 != header.fLocalCoordAttributeIndex) {
         GL_CALL(BindAttribLocation(fProgramID,
-                                   fDesc.fLocalCoordAttributeIndex,
+                                   header.fLocalCoordAttributeIndex,
                                    builder.localCoordsAttribute().c_str()));
     }
-    if (-1 != fDesc.fColorAttributeIndex) {
-        GL_CALL(BindAttribLocation(fProgramID, fDesc.fColorAttributeIndex, COL_ATTR_NAME));
+    if (-1 != header.fColorAttributeIndex) {
+        GL_CALL(BindAttribLocation(fProgramID, header.fColorAttributeIndex, COL_ATTR_NAME));
     }
-    if (-1 != fDesc.fCoverageAttributeIndex) {
-        GL_CALL(BindAttribLocation(fProgramID, fDesc.fCoverageAttributeIndex, COV_ATTR_NAME));
+    if (-1 != header.fCoverageAttributeIndex) {
+        GL_CALL(BindAttribLocation(fProgramID, header.fCoverageAttributeIndex, COV_ATTR_NAME));
     }
 
     const GrGLShaderBuilder::AttributePair* attribEnd = builder.getEffectAttributes().end();
     for (const GrGLShaderBuilder::AttributePair* attrib = builder.getEffectAttributes().begin();
          attrib != attribEnd;
          ++attrib) {
          GL_CALL(BindAttribLocation(fProgramID, attrib->fIndex, attrib->fName.c_str()));
     }
 
     GL_CALL(LinkProgram(fProgramID));
@@ skipping 40 matching lines @@
                 fUniformManager.setSampler(handle, texUnitIdx);
                 ++texUnitIdx;
             }
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLProgram::setData(GrGpuGL* gpu,
-                          GrColor color,
-                          GrColor coverage,
+                          GrDrawState::BlendOptFlags blendOpts,
+                          const GrEffectStage* stages[],
                           const GrDeviceCoordTexture* dstCopy,
                           SharedGLState* sharedState) {
     const GrDrawState& drawState = gpu->getDrawState();
 
+    GrColor color;
+    GrColor coverage;
+    if (blendOpts & GrDrawState::kEmitTransBlack_BlendOptFlag) {
+        color = 0;
+        coverage = 0;
+    } else if (blendOpts & GrDrawState::kEmitCoverage_BlendOptFlag) {
+        color = 0xffffffff;
+        coverage = drawState.getCoverage();
+    } else {
+        color = drawState.getColor();
+        coverage = drawState.getCoverage();
+    }
+
     this->setColor(drawState, color, sharedState);
     this->setCoverage(drawState, coverage, sharedState);
     this->setMatrixAndRenderTargetHeight(drawState);
 
     // Setup the SkXfermode::Mode-based colorfilter uniform if necessary
     if (GrGLUniformManager::kInvalidUniformHandle != fUniformHandles.fColorFilterUni &&
         fColorFilterColor != drawState.getColorFilterColor()) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(drawState.getColorFilterColor(), c);
         fUniformManager.set4fv(fUniformHandles.fColorFilterUni, 0, 1, c);
@@ skipping 16 matching lines @@
             static GrTextureParams kParams; // the default is clamp, nearest filtering.
             gpu->bindTexture(texUnitIdx, kParams, texture);
             ++texUnitIdx;
         } else {
             GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
                     fUniformHandles.fDstCopyScaleUni);
             GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
                     fUniformHandles.fDstCopySamplerUni);
         }
     } else {
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopyTopLeftUni);
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopyScaleUni);
-        GrAssert(GrGLUniformManager::kInvalidUniformHandle ==
-                    fUniformHandles.fDstCopySamplerUni);
+        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyTopLeftUni);
+        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopyScaleUni);
+        GrAssert(GrGLUniformManager::kInvalidUniformHandle == fUniformHandles.fDstCopySamplerUni);
     }
-    for (int s = 0; s < GrDrawState::kNumStages; ++s) {
-        if (NULL != fEffects[s]) {
-            const GrEffectStage& stage = drawState.getStage(s);
-            GrAssert(NULL != stage.getEffect());
 
-            bool explicitLocalCoords = -1 != fDesc.fLocalCoordAttributeIndex;
-            GrDrawEffect drawEffect(stage, explicitLocalCoords);
-            fEffects[s]->setData(fUniformManager, drawEffect);
-            int numSamplers = fUniformHandles.fEffectSamplerUnis[s].count();
+    int numEffects = fDesc.numTotalEffects();
+    for (int e = 0; e < numEffects; ++e) {
+        GrAssert(NULL != stages[e]);
+        // We may have omitted the GrGLEffect because of the color filter logic in genProgram.
+        // This can be removed when the color filter is an effect.
+        if (NULL != fEffects[e]) {
+            bool explicitLocalCoords = -1 != fDesc.getHeader().fLocalCoordAttributeIndex;
+            GrDrawEffect drawEffect(*stages[e], explicitLocalCoords);
+            fEffects[e]->setData(fUniformManager, drawEffect);
+            int numSamplers = fUniformHandles.fEffectSamplerUnis[e].count();
             for (int u = 0; u < numSamplers; ++u) {
-                UniformHandle handle = fUniformHandles.fEffectSamplerUnis[s][u];
+                UniformHandle handle = fUniformHandles.fEffectSamplerUnis[e][u];
                 if (GrGLUniformManager::kInvalidUniformHandle != handle) {
-                    const GrTextureAccess& access = (*stage.getEffect())->textureAccess(u);
+                    const GrTextureAccess& access = (*stages[e]->getEffect())->textureAccess(u);
                     GrGLTexture* texture = static_cast<GrGLTexture*>(access.getTexture());
                     gpu->bindTexture(texUnitIdx, access.getParams(), texture);
                     ++texUnitIdx;
                 }
             }
         }
     }
 }
 
 void GrGLProgram::setColor(const GrDrawState& drawState,
                            GrColor color,
                            SharedGLState* sharedState) {
+    const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasColorVertexAttribute()) {
-        switch (fDesc.fColorInput) {
+        switch (header.fColorInput) {
             case GrGLProgramDesc::kAttribute_ColorInput:
-                GrAssert(-1 != fDesc.fColorAttributeIndex);
+                GrAssert(-1 != header.fColorAttributeIndex);
                 if (sharedState->fConstAttribColor != color ||
-                    sharedState->fConstAttribColorIndex != fDesc.fColorAttributeIndex) {
+                    sharedState->fConstAttribColorIndex != header.fColorAttributeIndex) {
                     // OpenGL ES only supports the float varieties of glVertexAttrib
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(color, c);
-                    GL_CALL(VertexAttrib4fv(fDesc.fColorAttributeIndex, c));
+                    GL_CALL(VertexAttrib4fv(header.fColorAttributeIndex, c));
                     sharedState->fConstAttribColor = color;
-                    sharedState->fConstAttribColorIndex = fDesc.fColorAttributeIndex;
+                    sharedState->fConstAttribColorIndex = header.fColorAttributeIndex;
                 }
                 break;
             case GrGLProgramDesc::kUniform_ColorInput:
                 if (fColor != color) {
                     // OpenGL ES doesn't support unsigned byte varieties of glUniform
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(color, c);
                     GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
                              fUniformHandles.fColorUni);
                     fUniformManager.set4fv(fUniformHandles.fColorUni, 0, 1, c);
                     fColor = color;
                 }
                 sharedState->fConstAttribColorIndex = -1;
                 break;
             case GrGLProgramDesc::kSolidWhite_ColorInput:
             case GrGLProgramDesc::kTransBlack_ColorInput:
                 sharedState->fConstAttribColorIndex = -1;
                 break;
             default:
                 GrCrash("Unknown color type.");
         }
     } else {
         sharedState->fConstAttribColorIndex = -1;
     }
 }
 
 void GrGLProgram::setCoverage(const GrDrawState& drawState,
                               GrColor coverage,
                               SharedGLState* sharedState) {
+    const GrGLProgramDesc::KeyHeader& header = fDesc.getHeader();
     if (!drawState.hasCoverageVertexAttribute()) {
-        switch (fDesc.fCoverageInput) {
+        switch (header.fCoverageInput) {
             case GrGLProgramDesc::kAttribute_ColorInput:
                 if (sharedState->fConstAttribCoverage != coverage ||
-                    sharedState->fConstAttribCoverageIndex != fDesc.fCoverageAttributeIndex) {
+                    sharedState->fConstAttribCoverageIndex != header.fCoverageAttributeIndex) {
                     // OpenGL ES only supports the float varieties of  glVertexAttrib
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(coverage, c);
-                    GL_CALL(VertexAttrib4fv(fDesc.fCoverageAttributeIndex, c));
+                    GL_CALL(VertexAttrib4fv(header.fCoverageAttributeIndex, c));
                     sharedState->fConstAttribCoverage = coverage;
-                    sharedState->fConstAttribCoverageIndex = fDesc.fCoverageAttributeIndex;
+                    sharedState->fConstAttribCoverageIndex = header.fCoverageAttributeIndex;
                 }
                 break;
             case GrGLProgramDesc::kUniform_ColorInput:
                 if (fCoverage != coverage) {
                     // OpenGL ES doesn't support unsigned byte varieties of glUniform
                     GrGLfloat c[4];
                     GrColorToRGBAFloat(coverage, c);
                     GrAssert(GrGLUniformManager::kInvalidUniformHandle !=
                              fUniformHandles.fCoverageUni);
                     fUniformManager.set4fv(fUniformHandles.fCoverageUni, 0, 1, c);
@@ skipping 52 matching lines @@
             SkScalarToFloat(m[SkMatrix::kMTransX]),
             SkScalarToFloat(m[SkMatrix::kMTransY]),
             SkScalarToFloat(m[SkMatrix::kMPersp2])
         };
         fUniformManager.setMatrix3f(fUniformHandles.fViewMatrixUni, mt);
         fMatrixState.fViewMatrix = drawState.getViewMatrix();
         fMatrixState.fRenderTargetSize = size;
         fMatrixState.fRenderTargetOrigin = rt->origin();
     }
 }