Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/GrGLVertexArray.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLVertexArray_DEFINED
 #define GrGLVertexArray_DEFINED
 
 #include "GrGpuResource.h"
 #include "GrTypesPriv.h"
 #include "gl/GrGLDefines.h"
 #include "gl/GrGLFunctions.h"
 
 #include "SkTArray.h"
 
 class GrGLVertexBuffer;
 class GrGLIndexBuffer;
-class GrGpuGL;
+class GrGLGpu;
 
 struct GrGLAttribLayout {
     GrGLint     fCount;
     GrGLenum    fType;
     GrGLboolean fNormalized;
 };
 
 static inline const GrGLAttribLayout& GrGLAttribTypeToLayout(GrVertexAttribType type) {
     SkASSERT(type >= 0 && type < kGrVertexAttribTypeCount);
     static const GrGLAttribLayout kLayouts[kGrVertexAttribTypeCount] = {
@@ skipping 29 matching lines @@
         for (int i = 0; i < newCount; ++i) {
             fAttribArrayStates[i].invalidate();
         }
     }
 
     /**
      * This function enables and sets vertex attrib state for the specified attrib index. It is
      * assumed that the GrGLAttribArrayState is tracking the state of the currently bound vertex
      * array object.
      */
-    void set(const GrGpuGL*,
+    void set(const GrGLGpu*,
              int index,
              GrGLVertexBuffer*,
              GrGLint size,
              GrGLenum type,
              GrGLboolean normalized,
              GrGLsizei stride,
              GrGLvoid* offset);
 
     /**
      * This function disables vertex attribs not present in the mask. It is assumed that the
      * GrGLAttribArrayState is tracking the state of the currently bound vertex array object.
      */
-    void disableUnusedArrays(const GrGpuGL*, uint64_t usedAttribArrayMask);
+    void disableUnusedArrays(const GrGLGpu*, uint64_t usedAttribArrayMask);
 
     void invalidate() {
         int count = fAttribArrayStates.count();
         for (int i = 0; i < count; ++i) {
             fAttribArrayStates[i].invalidate();
         }
     }
 
     void notifyVertexBufferDelete(GrGLuint id) {
         int count = fAttribArrayStates.count();
@@ skipping 33 matching lines @@
 
     SkSTArray<16, AttribArrayState, true> fAttribArrayStates;
 };
 
 /**
  * This class represents an OpenGL vertex array object. It manages the lifetime of the vertex array
  * and is used to track the state of the vertex array to avoid redundant GL calls.
  */
 class GrGLVertexArray : public GrGpuResource {
 public:
-    GrGLVertexArray(GrGpuGL* gpu, GrGLint id, int attribCount);
+    GrGLVertexArray(GrGLGpu* gpu, GrGLint id, int attribCount);
 
     /**
      * Binds this vertex array. If the ID has been deleted or abandoned then NULL is returned.
      * Otherwise, the GrGLAttribArrayState that is tracking this vertex array's attrib bindings is
      * returned.
      */
     GrGLAttribArrayState* bind();
 
     /**
      * This is a version of the above function that also binds an index buffer to the vertex
@@ skipping 21 matching lines @@
 private:
     GrGLuint                fID;
     GrGLAttribArrayState    fAttribArrays;
     GrGLuint                fIndexBufferID;
     bool                    fIndexBufferIDIsValid;
 
     typedef GrGpuResource INHERITED;
 };
 
 #endif