Add a GrGpuGL reference for GrGLProgram/GrGLUniformManager

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 19 matching lines @@
  * across our shaders. But the driver determines the uniform locations
  * at link time. We don't need to remember the sampler uniform location
  * because we will bind a texture slot to it and never change it
  * Uniforms are program-local so we can't rely on fHWState to hold the
  * previous uniform state after a program change.
  */
 class GrGLProgram : public GrRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrGLProgram)
 
-    static GrGLProgram* Create(const GrGLContext& gl,
+    static GrGLProgram* Create(GrGpuGL* gpu,
                                const GrGLProgramDesc& desc,
                                const GrEffectStage* colorStages[],
                                const GrEffectStage* coverageStages[]);
 
     virtual ~GrGLProgram();
 
     /**
      * Call to abandon GL objects owned by this program.
      */
     void abandon();
@@ skipping 50 matching lines @@
             fRenderTargetOrigin = (GrSurfaceOrigin) -1;
         }
     };
 
     /**
      * This function uploads uniforms and calls each GrGLEffect's setData. It is called before a
      * draw occurs using the program after the program has already been bound. It also uses the
      * GrGpuGL object to bind the textures required by the GrGLEffects. The color and coverage
      * stages come from GrGLProgramDesc::Build().
      */
-    void setData(GrGpuGL*,
-                 GrDrawState::BlendOptFlags,
+    void setData(GrDrawState::BlendOptFlags,
                  const GrEffectStage* colorStages[],
                  const GrEffectStage* coverageStages[],
                  const GrDeviceCoordTexture* dstCopy, // can be NULL
                  SharedGLState*);
 
 private:
     typedef GrGLUniformManager::UniformHandle UniformHandle;
 
     // handles for uniforms (aside from per-effect samplers)
     struct UniformHandles {
@@ skipping 16 matching lines @@
     typedef SkSTArray<4, int, true> TextureUnitSArray;
 
     struct EffectAndSamplers {
         EffectAndSamplers() : fGLEffect(NULL) {}
         ~EffectAndSamplers() { delete fGLEffect; }
         GrGLEffect*         fGLEffect;
         SamplerUniSArray    fSamplerUnis;  // sampler uni handles for effect's GrTextureAccess
         TextureUnitSArray   fTextureUnits; // texture unit used for each entry of fSamplerUnis
     };
 
-    GrGLProgram(const GrGLContext& gl,
+    GrGLProgram(GrGpuGL* gpu,
                 const GrGLProgramDesc& desc,
                 const GrEffectStage* colorStages[],
                 const GrEffectStage* coverageStages[]);
 
     bool succeeded() const { return 0 != fProgramID; }
 
     /**
      * This is the heavy initialization routine for building a GLProgram. colorStages and
      * coverageStages correspond to the output of GrGLProgramDesc::Build().
      */
@@ skipping 12 matching lines @@
 
     // Sets the texture units for samplers
     void initSamplerUniforms();
     void initEffectSamplerUniforms(EffectAndSamplers* effect, int* texUnitIdx);
 
     bool compileShaders(const GrGLShaderBuilder& builder);
 
     const char* adjustInColor(const SkString& inColor) const;
 
     // Helper for setData().
-    void setEffectData(GrGpuGL* gpu, const GrEffectStage& stage, const EffectAndSamplers& effect);
+    void setEffectData(const GrEffectStage& stage, const EffectAndSamplers& effect);
 
     // Helper for setData(). Makes GL calls to specify the initial color when there is not
     // per-vertex colors.
     void setColor(const GrDrawState&, GrColor color, SharedGLState*);
 
     // Helper for setData(). Makes GL calls to specify the initial coverage when there is not
     // per-vertex coverages.
     void setCoverage(const GrDrawState&, GrColor coverage, SharedGLState*);
 
     // Helper for setData() that sets the view matrix and loads the render target height uniform
     void setMatrixAndRenderTargetHeight(const GrDrawState&);
 
     // GL IDs
     GrGLuint                    fVShaderID;
     GrGLuint                    fGShaderID;
     GrGLuint                    fFShaderID;
     GrGLuint                    fProgramID;
 
     // these reflect the current values of uniforms (GL uniform values travel with program)
     MatrixState                 fMatrixState;
     GrColor                     fColor;
     GrColor                     fCoverage;
     GrColor                     fColorFilterColor;
     int                         fDstCopyTexUnit;
 
     SkTArray<EffectAndSamplers> fColorEffects;
     SkTArray<EffectAndSamplers> fCoverageEffects;
 
     GrGLProgramDesc             fDesc;
-    const GrGLContext&          fContext;
+    GrGpuGL*                    fGpu;
 
     GrGLUniformManager          fUniformManager;
     UniformHandles              fUniformHandles;
 
     typedef GrRefCnt INHERITED;
 };
 
 #endif