Add ShaderBuilders to EmitArgs and remove gettings from ProgBuilder.

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 "GrAutoLocaleSetter.h"
@@ skipping 77 matching lines @@
                                                                         const char* name,
                                                                         GrGLSLVertToFrag* v,
                                                                         GrSLPrecision fsPrecision) {
     // This call is not used for non-NVPR backends.
     SkASSERT(fGpu->glCaps().shaderCaps()->pathRenderingSupport() &&
              fArgs.fPrimitiveProcessor->isPathRendering() &&
              !fArgs.fPrimitiveProcessor->willUseGeoShader() &&
              fArgs.fPrimitiveProcessor->numAttribs() == 0);
     this->addVarying(name, v, fsPrecision);
     SeparableVaryingInfo& varyingInfo = fSeparableVaryingInfos.push_back();
-    varyingInfo.fVariable = this->getFragmentShaderBuilder()->fInputs.back();
+    varyingInfo.fVariable = fFS.fInputs.back();
     varyingInfo.fLocation = fSeparableVaryingInfos.count() - 1;
     return SeparableVaryingHandle(varyingInfo.fLocation);
 }
 
 GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::internalAddUniformArray(
                                                                 uint32_t visibility,
                                                                 GrSLType type,
                                                                 GrSLPrecision precision,
                                                                 const char* name,
                                                                 bool mangleName,
@@ skipping 144 matching lines @@
                                             const char* outColor,
                                             const char* inColor) {
     GrGLInstalledFragProc* ifp = new GrGLInstalledFragProc;
 
     ifp->fGLProc.reset(fp.createGLSLInstance());
 
     SkSTArray<4, GrGLSLTextureSampler> samplers(fp.numTextures());
     this->emitSamplers(fp, &samplers, ifp);
 
     GrGLSLFragmentProcessor::EmitArgs args(this,
+                                           &fFS,
                                            fp,
                                            outColor,
                                            inColor,
                                            fOutCoords[index],
                                            samplers);
     ifp->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(fp);
     fFragmentProcessors->fProcs.push_back(ifp);
 }
 
 void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& gp,
                                             const char* outColor,
                                             const char* outCoverage) {
     SkASSERT(!fGeometryProcessor);
     fGeometryProcessor = new GrGLInstalledGeoProc;
 
     fGeometryProcessor->fGLProc.reset(gp.createGLSLInstance(*fGpu->glCaps().glslCaps()));
 
     SkSTArray<4, GrGLSLTextureSampler> samplers(gp.numTextures());
     this->emitSamplers(gp, &samplers, fGeometryProcessor);
 
-    GrGLSLGeometryProcessor::EmitArgs args(this, gp, outColor, outCoverage, samplers,
+    GrGLSLGeometryProcessor::EmitArgs args(this, &fVS, &fFS, gp, outColor, outCoverage, samplers,
                                          fCoordTransforms, &fOutCoords);
     fGeometryProcessor->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(gp);
 }
 
 void GrGLProgramBuilder::emitAndInstallXferProc(const GrXferProcessor& xp,
                                                 const GrGLSLExpr4& colorIn,
@@ skipping 15 matching lines @@
         fFS.enableCustomOutput();
     }
 
     SkString openBrace;
     openBrace.printf("{ // Xfer Processor: %s\n", xp.name());
     fFS.codeAppend(openBrace.c_str());
 
     SkSTArray<4, GrGLSLTextureSampler> samplers(xp.numTextures());
     this->emitSamplers(xp, &samplers, fXferProcessor);
 
-    GrGLSLXferProcessor::EmitArgs args(this, xp, colorIn.c_str(), coverageIn.c_str(),
-                                     fFS.getPrimaryColorOutputName(),
-                                     fFS.getSecondaryColorOutputName(), samplers);
+    GrGLSLXferProcessor::EmitArgs args(this, &fFS, xp, colorIn.c_str(), coverageIn.c_str(),
+                                       fFS.getPrimaryColorOutputName(),
+                                       fFS.getSecondaryColorOutputName(), samplers);
     fXferProcessor->fGLProc->emitCode(args);
 
     // We have to check that effects and the code they emit are consistent, ie if an effect
     // asks for dst color, then the emit code needs to follow suit
     verify(xp);
     fFS.codeAppend("}");
 }
 
 void GrGLProgramBuilder::verify(const GrPrimitiveProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
@@ skipping 200 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int i = 0; i < numProcs; ++i) {
         delete fProcs[i];
     }
 }