Rename GrGpuGL to GrGLGpu for consistency

src/gpu/gl/GrGLBufferImpl.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLBufferImpl.h"
 #include "GrGpuGL.h"
 
 #define GL_CALL(GPU, X) GR_GL_CALL(GPU->glInterface(), X)
 
 #ifdef SK_DEBUG
 #define VALIDATE() this->validate()
 #else
 #define VALIDATE() do {} while(false)
 #endif
 
 // GL_STREAM_DRAW triggers an optimization in Chromium's GPU process where a client's vertex buffer
 // objects are implemented as client-side-arrays on tile-deferred architectures.
 #define DYNAMIC_USAGE_PARAM GR_GL_STREAM_DRAW
 
-GrGLBufferImpl::GrGLBufferImpl(GrGpuGL* gpu, const Desc& desc, GrGLenum bufferType)
+GrGLBufferImpl::GrGLBufferImpl(GrGLGpu* gpu, const Desc& desc, GrGLenum bufferType)
     : fDesc(desc)
     , fBufferType(bufferType)
     , fMapPtr(NULL) {
     if (0 == desc.fID) {
         fCPUData = sk_malloc_flags(desc.fSizeInBytes, SK_MALLOC_THROW);
         fGLSizeInBytes = 0;
     } else {
         fCPUData = NULL;
         // We assume that the GL buffer was created at the desc's size initially.
         fGLSizeInBytes = fDesc.fSizeInBytes;
     }
     VALIDATE();
 }
 
-void GrGLBufferImpl::release(GrGpuGL* gpu) {
+void GrGLBufferImpl::release(GrGLGpu* gpu) {
     VALIDATE();
     // make sure we've not been abandoned or already released
     if (fCPUData) {
         sk_free(fCPUData);
         fCPUData = NULL;
     } else if (fDesc.fID && !fDesc.fIsWrapped) {
         GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID));
         if (GR_GL_ARRAY_BUFFER == fBufferType) {
             gpu->notifyVertexBufferDelete(fDesc.fID);
         } else {
             SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
             gpu->notifyIndexBufferDelete(fDesc.fID);
         }
         fDesc.fID = 0;
         fGLSizeInBytes = 0;
     }
     fMapPtr = NULL;
     VALIDATE();
 }
 
 void GrGLBufferImpl::abandon() {
     fDesc.fID = 0;
     fGLSizeInBytes = 0;
     fMapPtr = NULL;
     sk_free(fCPUData);
     fCPUData = NULL;
     VALIDATE();
 }
 
-void GrGLBufferImpl::bind(GrGpuGL* gpu) const {
+void GrGLBufferImpl::bind(GrGLGpu* gpu) const {
     VALIDATE();
     if (GR_GL_ARRAY_BUFFER == fBufferType) {
         gpu->bindVertexBuffer(fDesc.fID);
     } else {
         SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
         gpu->bindIndexBufferAndDefaultVertexArray(fDesc.fID);
     }
     VALIDATE();
 }
 
-void* GrGLBufferImpl::map(GrGpuGL* gpu) {
+void* GrGLBufferImpl::map(GrGLGpu* gpu) {
     VALIDATE();
     SkASSERT(!this->isMapped());
     if (0 == fDesc.fID) {
         fMapPtr = fCPUData;
     } else {
         switch (gpu->glCaps().mapBufferType()) {
             case GrGLCaps::kNone_MapBufferType:
                 VALIDATE();
                 return NULL;
             case GrGLCaps::kMapBuffer_MapBufferType:
@@ skipping 36 matching lines @@
                 GR_GL_CALL_RET(gpu->glInterface(),
                                fMapPtr,
                                MapBufferSubData(fBufferType, 0, fGLSizeInBytes, GR_GL_WRITE_ONLY));
                 break;
         }
     }
     VALIDATE();
     return fMapPtr;
 }
 
-void GrGLBufferImpl::unmap(GrGpuGL* gpu) {
+void GrGLBufferImpl::unmap(GrGLGpu* gpu) {
     VALIDATE();
     SkASSERT(this->isMapped());
     if (0 != fDesc.fID) {
         switch (gpu->glCaps().mapBufferType()) {
             case GrGLCaps::kNone_MapBufferType:
                 SkDEBUGFAIL("Shouldn't get here.");
                 return;
             case GrGLCaps::kMapBuffer_MapBufferType: // fall through
             case GrGLCaps::kMapBufferRange_MapBufferType:
                 this->bind(gpu);
                 GL_CALL(gpu, UnmapBuffer(fBufferType));
                 break;
             case GrGLCaps::kChromium_MapBufferType:
                 this->bind(gpu);
                 GR_GL_CALL(gpu->glInterface(), UnmapBufferSubData(fMapPtr));
                 break;
         }
     }
     fMapPtr = NULL;
 }
 
 bool GrGLBufferImpl::isMapped() const {
     VALIDATE();
     return SkToBool(fMapPtr);
 }
 
-bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) {
+bool GrGLBufferImpl::updateData(GrGLGpu* gpu, const void* src, size_t srcSizeInBytes) {
     SkASSERT(!this->isMapped());
     VALIDATE();
     if (srcSizeInBytes > fDesc.fSizeInBytes) {
         return false;
     }
     if (0 == fDesc.fID) {
         memcpy(fCPUData, src, srcSizeInBytes);
         return true;
     }
     this->bind(gpu);
@@ skipping 43 matching lines @@
 
 void GrGLBufferImpl::validate() const {
     SkASSERT(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
     // The following assert isn't valid when the buffer has been abandoned:
     // SkASSERT((0 == fDesc.fID) == (fCPUData));
     SkASSERT(0 != fDesc.fID || !fDesc.fIsWrapped);
     SkASSERT(NULL == fCPUData || 0 == fGLSizeInBytes);
     SkASSERT(NULL == fMapPtr || fCPUData || fGLSizeInBytes == fDesc.fSizeInBytes);
     SkASSERT(NULL == fCPUData || NULL == fMapPtr || fCPUData == fMapPtr);
 }