Replace uses of GrAssert by SkASSERT.

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"
 
@@ skipping 26 matching lines @@
     if (NULL != fCPUData) {
         VALIDATE();
         sk_free(fCPUData);
         fCPUData = NULL;
     } else if (fDesc.fID && !fDesc.fIsWrapped) {
         VALIDATE();
         GL_CALL(gpu, DeleteBuffers(1, &fDesc.fID));
         if (GR_GL_ARRAY_BUFFER == fBufferType) {
             gpu->notifyVertexBufferDelete(fDesc.fID);
         } else {
-            GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+            SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
             gpu->notifyIndexBufferDelete(fDesc.fID);
         }
         fDesc.fID = 0;
     }
     fLockPtr = NULL;
 }
 
 void GrGLBufferImpl::abandon() {
     fDesc.fID = 0;
     fLockPtr = NULL;
     sk_free(fCPUData);
     fCPUData = NULL;
 }
 
 void GrGLBufferImpl::bind(GrGpuGL* gpu) const {
     VALIDATE();
     if (GR_GL_ARRAY_BUFFER == fBufferType) {
         gpu->bindVertexBuffer(fDesc.fID);
     } else {
-        GrAssert(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+        SkASSERT(GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
         gpu->bindIndexBufferAndDefaultVertexArray(fDesc.fID);
     }
 }
 
 void* GrGLBufferImpl::lock(GrGpuGL* gpu) {
     VALIDATE();
-    GrAssert(!this->isLocked());
+    SkASSERT(!this->isLocked());
     if (0 == fDesc.fID) {
         fLockPtr = fCPUData;
     } else if (gpu->caps()->bufferLockSupport()) {
         this->bind(gpu);
         // Let driver know it can discard the old data
         GL_CALL(gpu, BufferData(fBufferType,
                                 fDesc.fSizeInBytes,
                                 NULL,
                                 fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW));
         GR_GL_CALL_RET(gpu->glInterface(),
                        fLockPtr,
                        MapBuffer(fBufferType, GR_GL_WRITE_ONLY));
     }
     return fLockPtr;
 }
 
 void GrGLBufferImpl::unlock(GrGpuGL* gpu) {
     VALIDATE();
-    GrAssert(this->isLocked());
+    SkASSERT(this->isLocked());
     if (0 != fDesc.fID) {
-        GrAssert(gpu->caps()->bufferLockSupport());
+        SkASSERT(gpu->caps()->bufferLockSupport());
         this->bind(gpu);
         GL_CALL(gpu, UnmapBuffer(fBufferType));
     }
     fLockPtr = NULL;
 }
 
 bool GrGLBufferImpl::isLocked() const {
     VALIDATE();
     return NULL != fLockPtr;
 }
 
 bool GrGLBufferImpl::updateData(GrGpuGL* gpu, const void* src, size_t srcSizeInBytes) {
-    GrAssert(!this->isLocked());
+    SkASSERT(!this->isLocked());
     VALIDATE();
     if (srcSizeInBytes > fDesc.fSizeInBytes) {
         return false;
     }
     if (0 == fDesc.fID) {
         memcpy(fCPUData, src, srcSizeInBytes);
         return true;
     }
     this->bind(gpu);
     GrGLenum usage = fDesc.fDynamic ? DYNAMIC_USAGE_PARAM : GR_GL_STATIC_DRAW;
@@ skipping 31 matching lines @@
         GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes + 1, NULL, usage));
         GL_CALL(gpu, BufferSubData(fBufferType, 0, srcSizeInBytes, src));
     } else {
         GL_CALL(gpu, BufferData(fBufferType, srcSizeInBytes, src, usage));
     }
 #endif
     return true;
 }
 
 void GrGLBufferImpl::validate() const {
-    GrAssert(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
+    SkASSERT(GR_GL_ARRAY_BUFFER == fBufferType || GR_GL_ELEMENT_ARRAY_BUFFER == fBufferType);
     // The following assert isn't valid when the buffer has been abandoned:
-    // GrAssert((0 == fDesc.fID) == (NULL != fCPUData));
-    GrAssert(0 != fDesc.fID || !fDesc.fIsWrapped);
-    GrAssert(NULL == fCPUData || NULL == fLockPtr || fCPUData == fLockPtr);
+    // SkASSERT((0 == fDesc.fID) == (NULL != fCPUData));
+    SkASSERT(0 != fDesc.fID || !fDesc.fIsWrapped);
+    SkASSERT(NULL == fCPUData || NULL == fLockPtr || fCPUData == fLockPtr);
 }