Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/GrGpuGL.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 GrGpuGL_DEFINED
 #define GrGpuGL_DEFINED
 
 #include "GrDrawState.h"
 #include "GrGLContext.h"
 #include "GrGLIRect.h"
 #include "GrGLIndexBuffer.h"
 #include "GrGLPathRendering.h"
 #include "GrGLProgram.h"
 #include "GrGLRenderTarget.h"
 #include "GrGLStencilBuffer.h"
 #include "GrGLTexture.h"
 #include "GrGLVertexArray.h"
 #include "GrGLVertexBuffer.h"
 #include "GrGpu.h"
 #include "GrOptDrawState.h"
 #include "SkTypes.h"
 
 #ifdef SK_DEVELOPER
 #define PROGRAM_CACHE_STATS
 #endif
 
-class GrGpuGL : public GrGpu {
+class GrGLGpu : public GrGpu {
 public:
-    GrGpuGL(const GrGLContext& ctx, GrContext* context);
-    virtual ~GrGpuGL();
+    GrGLGpu(const GrGLContext& ctx, GrContext* context);
+    virtual ~GrGLGpu();
 
     virtual void contextAbandoned() SK_OVERRIDE;
 
     const GrGLContext& glContext() const { return fGLContext; }
 
     const GrGLInterface* glInterface() const { return fGLContext.interface(); }
     const GrGLContextInfo& ctxInfo() const { return fGLContext; }
     GrGLStandard glStandard() const { return fGLContext.standard(); }
     GrGLVersion glVersion() const { return fGLContext.version(); }
     GrGLSLGeneration glslGeneration() const { return fGLContext.glslGeneration(); }
@@ skipping 129 matching lines @@
 
     // Subclasses should call this to flush the blend state.
     void flushBlend(const GrOptDrawState& optState);
 
     bool hasExtension(const char* ext) const { return fGLContext.hasExtension(ext); }
 
     static bool BlendCoeffReferencesConstant(GrBlendCoeff coeff);
 
     class ProgramCache : public ::SkNoncopyable {
     public:
-        ProgramCache(GrGpuGL* gpu);
+        ProgramCache(GrGLGpu* gpu);
         ~ProgramCache();
 
         void abandon();
         GrGLProgram* getProgram(const GrOptDrawState&);
 
     private:
         enum {
             // We may actually have kMaxEntries+1 shaders in the GL context because we create a new
             // shader before evicting from the cache.
             kMaxEntries = 128,
             kHashBits = 6,
         };
 
         struct Entry;
 
         struct ProgDescLess;
 
         // binary search for entry matching desc. returns index into fEntries that matches desc or ~
         // of the index of where it should be inserted.
         int search(const GrProgramDesc& desc) const;
 
         // sorted array of all the entries
         Entry*                      fEntries[kMaxEntries];
         // hash table based on lowest kHashBits bits of the program key. Used to avoid binary
         // searching fEntries.
         Entry*                      fHashTable[1 << kHashBits];
 
         int                         fCount;
         unsigned int                fCurrLRUStamp;
-        GrGpuGL*                    fGpu;
+        GrGLGpu*                    fGpu;
 #ifdef PROGRAM_CACHE_STATS
         int                         fTotalRequests;
         int                         fCacheMisses;
         int                         fHashMisses; // cache hit but hash table missed
 #endif
     };
 
     // flushes dithering, color-mask, and face culling stat
     void flushMiscFixedFunctionState(const GrOptDrawState&);
 
@@ skipping 101 matching lines @@
             }
         }
 
         void notifyVertexArrayDelete(GrGLuint id) {
             if (fBoundVertexArrayIDIsValid && fBoundVertexArrayID == id) {
                 // Does implicit bind to 0
                 fBoundVertexArrayID = 0;
             }
         }
 
-        void setVertexArrayID(GrGpuGL* gpu, GrGLuint arrayID) {
+        void setVertexArrayID(GrGLGpu* gpu, GrGLuint arrayID) {
             if (!gpu->glCaps().vertexArrayObjectSupport()) {
                 SkASSERT(0 == arrayID);
                 return;
             }
             if (!fBoundVertexArrayIDIsValid || arrayID != fBoundVertexArrayID) {
                 GR_GL_CALL(gpu->glInterface(), BindVertexArray(arrayID));
                 fBoundVertexArrayIDIsValid = true;
                 fBoundVertexArrayID = arrayID;
             }
         }
@@ skipping 11 matching lines @@
         void notifyIndexBufferDelete(GrGLuint id) {
             if (fDefaultVertexArrayBoundIndexBufferIDIsValid &&
                 id == fDefaultVertexArrayBoundIndexBufferID) {
                 fDefaultVertexArrayBoundIndexBufferID = 0;
             }
             if (fVBOVertexArray) {
                 fVBOVertexArray->notifyIndexBufferDelete(id);
             }
         }
 
-        void setVertexBufferID(GrGpuGL* gpu, GrGLuint id) {
+        void setVertexBufferID(GrGLGpu* gpu, GrGLuint id) {
             if (!fBoundVertexBufferIDIsValid || id != fBoundVertexBufferID) {
                 GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ARRAY_BUFFER, id));
                 fBoundVertexBufferIDIsValid = true;
                 fBoundVertexBufferID = id;
             }
         }
 
         /**
          * Binds the default vertex array and binds the index buffer. This is used when binding
          * an index buffer in order to update it.
          */
-        void setIndexBufferIDOnDefaultVertexArray(GrGpuGL* gpu, GrGLuint id) {
+        void setIndexBufferIDOnDefaultVertexArray(GrGLGpu* gpu, GrGLuint id) {
             this->setVertexArrayID(gpu, 0);
             if (!fDefaultVertexArrayBoundIndexBufferIDIsValid ||
                 id != fDefaultVertexArrayBoundIndexBufferID) {
                 GR_GL_CALL(gpu->glInterface(), BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER, id));
                 fDefaultVertexArrayBoundIndexBufferIDIsValid = true;
                 fDefaultVertexArrayBoundIndexBufferID = id;
             }
         }
 
         /**
          * Binds the vertex array object that should be used to render from the vertex buffer.
          * The vertex array is bound and its attrib array state object is returned. The vertex
          * buffer is bound. The index buffer (if non-NULL) is bound to the vertex array. The
          * returned GrGLAttribArrayState should be used to set vertex attribute arrays.
          */
-        GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGpuGL* gpu,
+        GrGLAttribArrayState* bindArrayAndBuffersToDraw(GrGLGpu* gpu,
                                                         const GrGLVertexBuffer* vbuffer,
                                                         const GrGLIndexBuffer* ibuffer);
 
     private:
         GrGLuint                fBoundVertexArrayID;
         GrGLuint                fBoundVertexBufferID;
         bool                    fBoundVertexArrayIDIsValid;
         bool                    fBoundVertexBufferIDIsValid;
 
         GrGLuint                fDefaultVertexArrayBoundIndexBufferID;
@@ skipping 38 matching lines @@
 
     // we record what stencil format worked last time to hopefully exit early
     // from our loop that tries stencil formats and calls check fb status.
     int fLastSuccessfulStencilFmtIdx;
 
     typedef GrGpu INHERITED;
     friend class GrGLPathRendering; // For accessing setTextureUnit.
 };
 
 #endif