Plumb OptDrawState down to VertexShaderBuilder

src/gpu/gl/builders/GrGLProgramBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
 #include "gl/GrGLUniformHandle.h"
@@ skipping 12 matching lines @@
 
 // number of each input/output type in a single allocation block
 static const int kVarsPerBlock = 8;
 
 // ES2 FS only guarantees mediump and lowp support
 static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-bool GrGLProgramBuilder::genProgram(const GrGeometryStage* geometryProcessor,
+bool GrGLProgramBuilder::genProgram(const GrOptDrawState& optState,
+                                    const GrGeometryStage* geometryProcessor,
                                     const GrFragmentStage* colorStages[],
                                     const GrFragmentStage* coverageStages[]) {
     const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
 
     fFS.emitCodeBeforeEffects();
 
     ///////////////////////////////////////////////////////////////////////////
     // get the initial color and coverage to feed into the first effect in each effect chain
 
     GrGLSLExpr4 inputColor;
@@ skipping 22 matching lines @@
     } else if (GrGLProgramDesc::kAllOnes_ColorInput == header.fCoverageInput) {
         inputCoverage = GrGLSLExpr4(1);
     }
 
     // Subclasses drive effect emitting
     this->createAndEmitEffects(geometryProcessor, colorStages, coverageStages, &inputColor,
                                &inputCoverage);
 
     fFS.emitCodeAfterEffects(inputColor, inputCoverage);
 
-    if (!this->finish()) {
+    if (!this->finish(optState)) {
         return false;
     }
 
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGLProgramBuilder::GrGLProgramBuilder(GrGpuGL* gpu,
                                        const GrGLProgramDesc& desc)
@@ skipping 133 matching lines @@
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
         samplers[t].fUniform = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                 kSampler2D_GrSLType,
                                                 name.c_str());
         SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler,
                                (samplers[t].fUniform, effect.textureAccess(t)));
     }
 }
 
-bool GrGLProgramBuilder::finish() {
+bool GrGLProgramBuilder::finish(const GrOptDrawState& optState) {
     SkASSERT(0 == fProgramID);
     GL_CALL_RET(fProgramID, CreateProgram());
     if (!fProgramID) {
         return false;
     }
 
     SkTDArray<GrGLuint> shadersToDelete;
 
     if (!this->compileAndAttachShaders(fProgramID, &shadersToDelete)) {
         GL_CALL(DeleteProgram(fProgramID));
         return false;
     }
 
-    this->bindProgramLocations(fProgramID);
+    this->bindProgramLocations(optState, fProgramID);
 
     GL_CALL(LinkProgram(fProgramID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = !fGpu->ctxInfo().isChromium();
 #ifdef SK_DEBUG
     checkLinked = true;
 #endif
     if (checkLinked) {
         GrGLint linked = GR_GL_INIT_ZERO;
@@ skipping 26 matching lines @@
     }
 
     return true;
 }
 
 bool GrGLProgramBuilder::compileAndAttachShaders(GrGLuint programId,
                                                  SkTDArray<GrGLuint>* shaderIds) const {
     return fFS.compileAndAttachShaders(programId, shaderIds);
 }
 
-void GrGLProgramBuilder::bindProgramLocations(GrGLuint programId) {
+void GrGLProgramBuilder::bindProgramLocations(const GrOptDrawState& optState,
+                                              GrGLuint programId) {
     fFS.bindProgramLocations(programId);
 
     // skbug.com/2056
     bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
     if (usingBindUniform) {
         int count = fUniforms.count();
         for (int i = 0; i < count; ++i) {
             GL_CALL(BindUniformLocation(programId, i, fUniforms[i].fVariable.c_str()));
             fUniforms[i].fLocation = i;
         }
@@ skipping 19 matching lines @@
                     GetProgramResourceLocation(programId,
                                                GR_GL_FRAGMENT_INPUT,
                                                fSeparableVaryingInfos[i].fVariable.c_str()));
         fSeparableVaryingInfos[i].fLocation = location;
     }
 }
 
 const GrGLContextInfo& GrGLProgramBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }