remove proc key

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 232 matching lines @@
 }
 
 void GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor,
                                              GrGLSLExpr4* inputCoverage) {
     fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
     int numProcs = fOptState.numFragmentStages();
     this->emitAndInstallFragProcs(0, fOptState.numColorStages(), inputColor);
     if (fOptState.hasGeometryProcessor()) {
         const GrGeometryProcessor& gp = *fOptState.getGeometryProcessor();
         fVS.emitAttributes(gp);
-        ProcKeyProvider keyProvider(&fDesc,
-                                    ProcKeyProvider::kGeometry_ProcessorType,
-                                    GrGLProgramDescBuilder::kProcessorKeyOffsetsAndLengthOffset);
         GrGLSLExpr4 output;
-        this->emitAndInstallProc<GrGeometryProcessor>(gp, 0, keyProvider, *inputCoverage, &output);
+        this->emitAndInstallProc<GrGeometryProcessor>(gp, 0, *inputCoverage, &output);
         *inputCoverage = output;
     }
     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 GrPendingFragmentStage& stage = fOptState.getFragmentStage(e);
-        this->emitAndInstallProc<GrPendingFragmentStage>(stage, e, keyProvider, *inOut, &output);
+        this->emitAndInstallProc<GrPendingFragmentStage>(stage, e, *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,
                                             const GrGLSLExpr4& input,
                                             GrGLSLExpr4* output) {
     // Program builders have a bit of state we need to clear with each effect
     AutoStageAdvance adv(this);
 
     // create var to hold stage result.  If we already have a valid output name, just use that
     // otherwise create a new mangled one.
     SkString outColorName;
     if (output->isValid()) {
         outColorName = output->c_str();
     } else {
         this->nameVariable(&outColorName, '\0', "output");
     }
     fFS.codeAppendf("vec4 %s;", outColorName.c_str());
     *output = outColorName;
 
     // Enclose custom code in a block to avoid namespace conflicts
     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());
+    this->emitAndInstallProc(proc, output->c_str(), input.isOnes() ? NULL : input.c_str());
 
     fFS.codeAppend("}");
 }
 
 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);
 
     // Fragment processors can have coord transforms
     SkSTArray<2, GrGLProcessor::TransformedCoords> coords(fp.numTransforms());
     this->emitTransforms(fs, &coords, ifp);
 
-    ifp->fGLProc->emitCode(this, fp, key, outColor, inColor, coords, samplers);
+    ifp->fGLProc->emitCode(this, fp, outColor, inColor, coords, samplers);
 
     // 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 GrGeometryProcessor& gp,
-                                            const GrProcessorKey& key,
                                             const char* outCoverage,
                                             const char* inCoverage) {
     SkASSERT(!fGeometryProcessor);
     fGeometryProcessor = SkNEW(GrGLInstalledGeoProc);
 
     fGeometryProcessor->fGLProc.reset(gp.getFactory().createGLInstance(gp));
 
     SkSTArray<4, GrGLProcessor::TextureSampler> samplers(gp.numTextures());
     this->emitSamplers(gp, &samplers, fGeometryProcessor);
 
-    GrGLGeometryProcessor::EmitArgs args(this, gp, key, outCoverage, inCoverage, samplers);
+    GrGLGeometryProcessor::EmitArgs args(this, gp, outCoverage, inCoverage, samplers);
     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::verify(const GrGeometryProcessor& gp) {
     SkASSERT(fFS.hasReadFragmentPosition() == gp.willReadFragmentPosition());
 }
@@ skipping 164 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }