Don't call bindTexture from GrGLProgram

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/GrGLGeometryProcessor.h"
@@ skipping 20 matching lines @@
     GrGLNvprProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
         : INHERITED(gpu, args) {}
 
     GrGLProgram* createProgram(GrGLuint programID) override {
         // this is just for nvpr es, which has separable varyings that are plugged in after
         // building
         GrGLPathProcessor* pathProc =
                 static_cast<GrGLPathProcessor*>(fGeometryProcessor->fGLProc.get());
         pathProc->resolveSeparableVaryings(fGpu, programID);
         return SkNEW_ARGS(GrGLNvprProgram, (fGpu, this->desc(), fUniformHandles, programID,
-                                            fUniforms,
-                                            fGeometryProcessor,
-                                            fXferProcessor, fFragmentProcessors.get()));
+                                            fUniforms, fGeometryProcessor, fXferProcessor,
+                                            fFragmentProcessors.get(), &fSamplerUniforms));
     }
 
 private:
     typedef GrGLProgramBuilder INHERITED;
 };
 
 
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ skipping 37 matching lines @@
 GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
     , fOutOfStage(true)
     , fStageIndex(-1)
     , fGeometryProcessor(NULL)
     , fXferProcessor(NULL)
     , fArgs(args)
     , fGpu(gpu)
-    , fUniforms(kVarsPerBlock) {
+    , fUniforms(kVarsPerBlock)
+    , fSamplerUniforms(4) {
 }
 
 void GrGLProgramBuilder::addVarying(const char* name,
                                     GrGLVarying* varying,
                                     GrSLPrecision fsPrecision) {
     SkASSERT(varying);
     if (varying->vsVarying()) {
         fVS.addVarying(name, varying);
     }
     if (this->primitiveProcessor().willUseGeoShader()) {
@@ skipping 262 matching lines @@
 }
 
 void GrGLProgramBuilder::verify(const GrFragmentProcessor& fp) {
     SkASSERT(fFS.hasReadFragmentPosition() == fp.willReadFragmentPosition());
 }
 
 template <class Proc>
 void GrGLProgramBuilder::emitSamplers(const GrProcessor& processor,
                                       GrGLProcessor::TextureSamplerArray* outSamplers,
                                       GrGLInstalledProc<Proc>* ip) {
+    SkDEBUGCODE(ip->fSamplersIdx = fSamplerUniforms.count();)
     int numTextures = processor.numTextures();
-    ip->fSamplers.push_back_n(numTextures);
+    UniformHandle* localSamplerUniforms = fSamplerUniforms.push_back_n(numTextures);
     SkString name;
     for (int t = 0; t < numTextures; ++t) {
         name.printf("Sampler%d", t);
-        ip->fSamplers[t].fUniform = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                     kSampler2D_GrSLType, kDefault_GrSLPrecision,
-                                                     name.c_str());
+        localSamplerUniforms[t] = this->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                                                   kSampler2D_GrSLType, kDefault_GrSLPrecision,
+                                                   name.c_str());
         SkNEW_APPEND_TO_TARRAY(outSamplers, GrGLProcessor::TextureSampler,
-                               (ip->fSamplers[t].fUniform, processor.textureAccess(t)));
+                               (localSamplerUniforms[t], processor.textureAccess(t)));
     }
 }
 
 GrGLProgram* GrGLProgramBuilder::finalize() {
     // verify we can get a program id
     GrGLuint programID;
     GL_CALL_RET(programID, CreateProgram());
     if (0 == programID) {
         return NULL;
     }
@@ skipping 87 matching lines @@
     cleanupShaders(shaderIDs);
 }
 void GrGLProgramBuilder::cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs) {
     for (int i = 0; i < shaderIDs.count(); ++i) {
       GL_CALL(DeleteShader(shaderIDs[i]));
     }
 }
 
 GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
     return SkNEW_ARGS(GrGLProgram, (fGpu, this->desc(), fUniformHandles, programID, fUniforms,
-                                    fGeometryProcessor, fXferProcessor, fFragmentProcessors.get()));
+                                    fGeometryProcessor, fXferProcessor, fFragmentProcessors.get(),
+                                    &fSamplerUniforms));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
     int numProcs = fProcs.count();
     for (int e = 0; e < numProcs; ++e) {
         SkDELETE(fProcs[e]);
     }
 }