Create GrOptDrawState before recording draw in GrInOrderDrawBuffer

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 "GrGLProgramBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLSLPrettyPrint.h"
@@ skipping 248 matching lines @@
     }
     this->emitAndInstallFragProcs(fOptState.numColorStages(), numProcs,  inputCoverage);
 }
 
 void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut) {
     ProcKeyProvider keyProvider(&fDesc,
                                 ProcKeyProvider::kFragment_ProcessorType,
                                 GrGLProgramDescBuilder::kProcessorKeyOffsetsAndLengthOffset);
     for (int e = procOffset; e < numProcs; ++e) {
         GrGLSLExpr4 output;
-        const GrFragmentStage& stage = fOptState.getFragmentStage(e);
-        this->emitAndInstallProc<GrFragmentStage>(stage, e, keyProvider, *inOut, &output);
+        const GrPendingFragmentStage& stage = fOptState.getFragmentStage(e);
+        this->emitAndInstallProc<GrPendingFragmentStage>(stage, e, keyProvider, *inOut, &output);
         *inOut = output;
     }
 }
 
 // TODO Processors cannot output zeros because an empty string is all 1s
 // the fix is to allow effects to take the GrGLSLExpr4 directly
 template <class Proc>
 void GrGLProgramBuilder::emitAndInstallProc(const Proc& proc,
                                             int index,
                                             const ProcKeyProvider& keyProvider,
@@ skipping 17 matching lines @@
     SkString openBrace;
     openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
     fFS.codeAppend(openBrace.c_str());
 
     this->emitAndInstallProc(proc, keyProvider.get(index), output->c_str(),
                              input.isOnes() ? NULL : input.c_str());
 
     fFS.codeAppend("}");
 }
 
-void GrGLProgramBuilder::emitAndInstallProc(const GrFragmentStage& fs,
+void GrGLProgramBuilder::emitAndInstallProc(const GrPendingFragmentStage& fs,
                                             const GrProcessorKey& key,
                                             const char* outColor,
                                             const char* inColor) {
     GrGLInstalledFragProc* ifp = SkNEW_ARGS(GrGLInstalledFragProc, (fVS.hasLocalCoords()));
 
     const GrFragmentProcessor& fp = *fs.getProcessor();
     ifp->fGLProc.reset(fp.getFactory().createGLInstance(fp));
 
     SkSTArray<4, GrGLProcessor::TextureSampler> samplers(fp.numTextures());
     this->emitSamplers(fp, &samplers, ifp);
@@ skipping 32 matching lines @@
 
 void GrGLProgramBuilder::verify(const GrGeometryProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
 }
 
 void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) {
     SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
     SkASSERT(fFS.hasReadDstColor() == fp.willReadDstColor());
 }
 
-void GrGLProgramBuilder::emitTransforms(const GrFragmentStage& effectStage,
+void GrGLProgramBuilder::emitTransforms(const GrPendingFragmentStage& stage,
                                         GrGLProcessor::TransformedCoordsArray* outCoords,
                                         GrGLInstalledFragProc* ifp) {
-    const GrFragmentProcessor* effect = effectStage.getProcessor();
-    int numTransforms = effect->numTransforms();
+    const GrFragmentProcessor* processor = stage.getProcessor();
+    int numTransforms = processor->numTransforms();
     ifp->fTransforms.push_back_n(numTransforms);
 
     for (int t = 0; t < numTransforms; t++) {
         const char* uniName = "StageMatrix";
-        GrSLType varyingType =
-                effectStage.isPerspectiveCoordTransform(t, fVS.hasLocalCoords()) ?
-                        kVec3f_GrSLType :
-                        kVec2f_GrSLType;
-
+        GrSLType varyingType = stage.isPerspectiveCoordTransform(t) ? kVec3f_GrSLType :
+                                                                      kVec2f_GrSLType;
         SkString suffixedUniName;
         if (0 != t) {
             suffixedUniName.append(uniName);
             suffixedUniName.appendf("_%i", t);
             uniName = suffixedUniName.c_str();
         }
         ifp->fTransforms[t].fHandle = this->addUniform(GrGLProgramBuilder::kVertex_Visibility,
                                                        kMat33f_GrSLType,
                                                        uniName,
                                                        &uniName).toShaderBuilderIndex();
 
         const char* varyingName = "MatrixCoord";
         SkString suffixedVaryingName;
         if (0 != t) {
             suffixedVaryingName.append(varyingName);
             suffixedVaryingName.appendf("_%i", t);
             varyingName = suffixedVaryingName.c_str();
         }
-        const char* coords = kPosition_GrCoordSet == effect->coordTransform(t).sourceCoords() ?
+        const char* coords = kPosition_GrCoordSet == processor->coordTransform(t).sourceCoords() ?
                                                      fVS.positionAttribute().c_str() :
                                                      fVS.localCoordsAttribute().c_str();
         GrGLVertToFrag v(varyingType);
         this->addCoordVarying(varyingName, &v, uniName, coords);
 
         SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
         SkNEW_APPEND_TO_TARRAY(outCoords, GrGLProcessor::TransformedCoords,
                                (SkString(v.fsIn()), varyingType));
     }
 }
@@ skipping 118 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }