Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/builders/GrGLProgramBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramBuilder_DEFINED
 #define GrGLProgramBuilder_DEFINED
 
@@ skipping 53 matching lines @@
 
     virtual const GrGLShaderVar& getUniformVariable(UniformHandle u) const = 0;
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     virtual const char* getUniformCStr(UniformHandle u) const = 0;
 
     virtual const GrGLContextInfo& ctxInfo() const = 0;
 
-    virtual GrGpuGL* gpu() const = 0;
+    virtual GrGLGpu* gpu() const = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
 // TODO move this into GrGLGPBuilder and move them both out of this file
 class GrGLVarying {
 public:
     bool vsVarying() const { return kVertToFrag_Varying == fVarying ||
@@ skipping 113 matching lines @@
                            public GrGLFPBuilder,
                            public GrGLXPBuilder {
 public:
     /** Generates a shader program.
      *
      * The program implements what is specified in the stages given as input.
      * After successful generation, the builder result objects are available
      * to be used.
      * @return true if generation was successful.
      */
-    static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpuGL*);
+    static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGLGpu*);
 
     UniformHandle addUniformArray(uint32_t visibility,
                                   GrSLType type,
                                   GrSLPrecision precision,
                                   const char* name,
                                   int arrayCount,
                                   const char** outName) SK_OVERRIDE;
 
     const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
         return fUniforms[u.toShaderBuilderIndex()].fVariable;
     }
 
     const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
         return this->getUniformVariable(u).c_str();
     }
 
     const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
 
-    GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
+    GrGLGpu* gpu() const SK_OVERRIDE { return fGpu; }
 
     GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
     GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
 
     void addVarying(
             const char* name,
             GrGLVarying*,
             GrSLPrecision fsPrecision = kDefault_GrSLPrecision) SK_OVERRIDE;
 
     void addPassThroughAttribute(const GrGeometryProcessor::GrAttribute*,
@@ skipping 14 matching lines @@
         UniformHandle       fDstCopyScaleUni;
         UniformHandle       fDstCopySamplerUni;
     };
 
 protected:
     typedef GrGLProgramDataManager::UniformInfo UniformInfo;
     typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
 
     static GrGLProgramBuilder* CreateProgramBuilder(const GrOptDrawState&,
                                                     bool hasGeometryProcessor,
-                                                    GrGpuGL*);
+                                                    GrGLGpu*);
 
-    GrGLProgramBuilder(GrGpuGL*, const GrOptDrawState&);
+    GrGLProgramBuilder(GrGLGpu*, const GrOptDrawState&);
 
     const GrOptDrawState& optState() const { return fOptState; }
     const GrProgramDesc& desc() const { return fDesc; }
     const GrProgramDesc::KeyHeader& header() const { return fDesc.header(); }
 
     // Generates a name for a variable. The generated string will be name prefixed by the prefix
     // char (unless the prefix is '\0'). It also mangles the name to be stage-specific if we're
     // generating stage code.
     void nameVariable(SkString* out, char prefix, const char* name);
     // Generates a possibly mangled name for a stage variable and writes it to the fragment shader.
@@ skipping 95 matching lines @@
     GrGLFragmentShaderBuilder fFS;
     bool fOutOfStage;
     int fStageIndex;
 
     GrGLInstalledGeoProc* fGeometryProcessor;
     GrGLInstalledXferProc* fXferProcessor;
     SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     const GrOptDrawState& fOptState;
     const GrProgramDesc& fDesc;
-    GrGpuGL* fGpu;
+    GrGLGpu* fGpu;
     UniformInfoArray fUniforms;
     SkSTArray<16, TransformVarying, true> fCoordVaryings;
 
     friend class GrGLShaderBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 
 /**
@@ skipping 46 matching lines @@
     SkAutoTDelete<GrGLFragmentProcessor> fGLProc;
     SkSTArray<2, Transform, true>        fTransforms;
 };
 
 struct GrGLInstalledFragProcs : public SkRefCnt {
     virtual ~GrGLInstalledFragProcs();
     SkSTArray<8, GrGLInstalledFragProc*, true> fProcs;
 };
 
 #endif