Don't call bindTexture from GrGLProgram

src/gpu/gl/GrGLProgram.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrGLProgram_DEFINED
 #define GrGLProgram_DEFINED
@@ skipping 72 matching lines @@
                 destVec[2] = -2.f / fRenderTargetSize.fHeight;
                 destVec[3] = 1.f;
             } else {
                 destVec[2] = 2.f / fRenderTargetSize.fHeight;
                 destVec[3] = -1.f;
             }
         }
     };
 
     /**
-     * This function uploads uniforms and calls each GrGLProcessor's setData. It is called before a
-     * draw occurs using the program after the program has already been bound. It also uses the
-     * GrGLGpu object to bind the textures required by the GrGLProcessors. The color and coverage
-     * stages come from GrGLProgramDesc::Build().
+     * This function uploads uniforms, calls each GrGLProcessor's setData, and retrieves the
+     * textures that need to be bound on each unit. It is the caller's responsibility to ensure
+     * the program is bound before calling, and to bind the outgoing textures to their respective
+     * units upon return. (Each index in the array corresponds to its matching GL texture unit.)
      */
-    void setData(const GrPrimitiveProcessor&, const GrPipeline&, const GrBatchTracker&);
+    void setData(const GrPrimitiveProcessor&, const GrPipeline&, const GrBatchTracker&,
+                 SkTArray<const GrTextureAccess*>* textureBindings);
 
 protected:
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
     typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
 
     GrGLProgram(GrGLGpu*,
                 const GrProgramDesc&,
                 const BuiltinUniformHandles&,
                 GrGLuint programID,
                 const UniformInfoArray&,
                 GrGLInstalledGeoProc* geometryProcessor,
                 GrGLInstalledXferProc* xferProcessor,
-                GrGLInstalledFragProcs* fragmentProcessors);
-
-    // Sets the texture units for samplers.
-    void initSamplerUniforms();
-    template <class Proc>
-    void initSamplers(Proc*, int* texUnitIdx);
+                GrGLInstalledFragProcs* fragmentProcessors,
+                SkTArray<UniformHandle>* passSamplerUniforms);
 
     // A templated helper to loop over effects, set the transforms(via subclass) and bind textures
-    void setFragmentData(const GrPrimitiveProcessor&, const GrPipeline&);
+    void setFragmentData(const GrPrimitiveProcessor&, const GrPipeline&,
+                         SkTArray<const GrTextureAccess*>* textureBindings);
     virtual void setTransformData(const GrPrimitiveProcessor&,
                                   const GrPendingFragmentStage&,
                                   int index,
                                   GrGLInstalledFragProc*);
-    template <class Proc>
-    void bindTextures(const Proc*, const GrProcessor&);
 
     /*
      * Legacy NVPR needs a hook here to flush path tex gen settings.
      * TODO when legacy nvpr is removed, remove this call.
      */
     virtual void didSetData() {}
 
     // Helper for setData() that sets the view matrix and loads the render target height uniform
     void setRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&);
     virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&);
 
     // these reflect the current values of uniforms (GL uniform values travel with program)
     RenderTargetState fRenderTargetState;
     GrColor fColor;
     uint8_t fCoverage;
     int fDstTextureUnit;
     BuiltinUniformHandles fBuiltinUniformHandles;
     GrGLuint fProgramID;
 
     // the installed effects
     SkAutoTDelete<GrGLInstalledGeoProc> fGeometryProcessor;
     SkAutoTDelete<GrGLInstalledXferProc> fXferProcessor;
     SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     GrProgramDesc fDesc;
     GrGLGpu* fGpu;
     GrGLProgramDataManager fProgramDataManager;
+    SkTArray<UniformHandle> fSamplerUniforms;
 
     friend class GrGLProgramBuilder;
 
     typedef SkRefCnt INHERITED;
 };
 
 /*
  * Below are slight specializations of the program object for the different types of programs
  * The default GrGL programs consist of at the very least a vertex and fragment shader.
  * Legacy Nvpr only has a fragment shader, 1.3+ Nvpr ignores the vertex shader, but both require
  * specialized methods for setting transform data. Both types of NVPR also require setting the
  * projection matrix through a special function call
  */
 class GrGLNvprProgram : public GrGLProgram {
 protected:
     GrGLNvprProgram(GrGLGpu*,
                     const GrProgramDesc&,
                     const BuiltinUniformHandles&,
                     GrGLuint programID,
                     const UniformInfoArray&,
                     GrGLInstalledGeoProc*,
                     GrGLInstalledXferProc* xferProcessor,
-                    GrGLInstalledFragProcs* fragmentProcessors);
+                    GrGLInstalledFragProcs* fragmentProcessors,
+                    SkTArray<UniformHandle>* passSamplerUniforms);
 
 private:
     void didSetData() override;
     virtual void setTransformData(const GrPrimitiveProcessor&,
                                   const GrPendingFragmentStage&,
                                   int index,
                                   GrGLInstalledFragProc*) override;
     virtual void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&);
 
     friend class GrGLNvprProgramBuilder;
 
     typedef GrGLProgram INHERITED;
 };
 
 #endif