Replace uses of GrAssert by SkASSERT.

src/gpu/GrGpu.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpu.h"
@@ skipping 47 matching lines @@
 }
 
 void GrGpu::abandonResources() {
 
     fClipMaskManager.releaseResources();
 
     while (NULL != fResourceList.head()) {
         fResourceList.head()->abandon();
     }
 
-    GrAssert(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
+    SkASSERT(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
     GrSafeSetNull(fQuadIndexBuffer);
     delete fVertexPool;
     fVertexPool = NULL;
     delete fIndexPool;
     fIndexPool = NULL;
 }
 
 void GrGpu::releaseResources() {
 
     fClipMaskManager.releaseResources();
 
     while (NULL != fResourceList.head()) {
         fResourceList.head()->release();
     }
 
-    GrAssert(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
+    SkASSERT(NULL == fQuadIndexBuffer || !fQuadIndexBuffer->isValid());
     GrSafeSetNull(fQuadIndexBuffer);
     delete fVertexPool;
     fVertexPool = NULL;
     delete fIndexPool;
     fIndexPool = NULL;
 }
 
 void GrGpu::insertResource(GrResource* resource) {
-    GrAssert(NULL != resource);
-    GrAssert(this == resource->getGpu());
+    SkASSERT(NULL != resource);
+    SkASSERT(this == resource->getGpu());
 
     fResourceList.addToHead(resource);
 }
 
 void GrGpu::removeResource(GrResource* resource) {
-    GrAssert(NULL != resource);
-    GrAssert(this == resource->getGpu());
+    SkASSERT(NULL != resource);
+    SkASSERT(this == resource->getGpu());
 
     fResourceList.remove(resource);
 }
 
 
 void GrGpu::unimpl(const char msg[]) {
 #if GR_DEBUG
     GrPrintf("--- GrGpu unimplemented(\"%s\")\n", msg);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrTexture* GrGpu::createTexture(const GrTextureDesc& desc,
                                 const void* srcData, size_t rowBytes) {
     if (kUnknown_GrPixelConfig == desc.fConfig) {
         return NULL;
     }
 
     this->handleDirtyContext();
     GrTexture* tex = this->onCreateTexture(desc, srcData, rowBytes);
     if (NULL != tex &&
         (kRenderTarget_GrTextureFlagBit & desc.fFlags) &&
         !(kNoStencil_GrTextureFlagBit & desc.fFlags)) {
-        GrAssert(NULL != tex->asRenderTarget());
+        SkASSERT(NULL != tex->asRenderTarget());
         // TODO: defer this and attach dynamically
         if (!this->attachStencilBufferToRenderTarget(tex->asRenderTarget())) {
             tex->unref();
             return NULL;
         }
     }
     return tex;
 }
 
 bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt) {
-    GrAssert(NULL == rt->getStencilBuffer());
+    SkASSERT(NULL == rt->getStencilBuffer());
     GrStencilBuffer* sb =
         this->getContext()->findStencilBuffer(rt->width(),
                                               rt->height(),
                                               rt->numSamples());
     if (NULL != sb) {
         rt->setStencilBuffer(sb);
         bool attached = this->attachStencilBufferToRenderTarget(sb, rt);
         if (!attached) {
             rt->setStencilBuffer(NULL);
         }
@@ skipping 43 matching lines @@
     this->handleDirtyContext();
     return this->onCreateVertexBuffer(size, dynamic);
 }
 
 GrIndexBuffer* GrGpu::createIndexBuffer(uint32_t size, bool dynamic) {
     this->handleDirtyContext();
     return this->onCreateIndexBuffer(size, dynamic);
 }
 
 GrPath* GrGpu::createPath(const SkPath& path) {
-    GrAssert(this->caps()->pathStencilingSupport());
+    SkASSERT(this->caps()->pathStencilingSupport());
     this->handleDirtyContext();
     return this->onCreatePath(path);
 }
 
 void GrGpu::clear(const SkIRect* rect,
                   GrColor color,
                   GrRenderTarget* renderTarget) {
     GrDrawState::AutoRenderTargetRestore art;
     if (NULL != renderTarget) {
         art.set(this->drawState(), renderTarget);
     }
     if (NULL == this->getDrawState().getRenderTarget()) {
-        GrAssert(0);
+        SkASSERT(0);
         return;
     }
     this->handleDirtyContext();
     this->onClear(rect, color);
 }
 
 void GrGpu::forceRenderTargetFlush() {
     this->handleDirtyContext();
     this->onForceRenderTargetFlush();
 }
@@ skipping 10 matching lines @@
 bool GrGpu::writeTexturePixels(GrTexture* texture,
                                int left, int top, int width, int height,
                                GrPixelConfig config, const void* buffer,
                                size_t rowBytes) {
     this->handleDirtyContext();
     return this->onWriteTexturePixels(texture, left, top, width, height,
                                       config, buffer, rowBytes);
 }
 
 void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
-    GrAssert(target);
+    SkASSERT(target);
     this->handleDirtyContext();
     this->onResolveRenderTarget(target);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static const int MAX_QUADS = 1 << 12; // max possible: (1 << 14) - 1;
 
 GR_STATIC_ASSERT(4 * MAX_QUADS <= 65535);
@@ skipping 68 matching lines @@
     newState.fPoolStartVertex = DEBUG_INVAL_START_IDX;
     newState.fPoolIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
     newState.fPoolStartIndex = DEBUG_INVAL_START_IDX;
 #else
     (void) newState; // silence compiler warning
 #endif
 }
 
 void GrGpu::geometrySourceWillPop(const GeometrySrcState& restoredState) {
     // if popping last entry then pops are unbalanced with pushes
-    GrAssert(fGeomPoolStateStack.count() > 1);
+    SkASSERT(fGeomPoolStateStack.count() > 1);
     fGeomPoolStateStack.pop_back();
 }
 
 void GrGpu::onDraw(const DrawInfo& info) {
     this->handleDirtyContext();
     GrDrawState::AutoRestoreEffects are;
     if (!this->setupClipAndFlushState(PrimTypeToDrawType(info.primitiveType()),
                                       info.getDstCopy(),
                                       &are)) {
         return;
@@ skipping 10 matching lines @@
     this->setStencilPathSettings(*path, fill, this->drawState()->stencil());
     GrDrawState::AutoRestoreEffects are;
     if (!this->setupClipAndFlushState(kStencilPath_DrawType, NULL, &are)) {
         return;
     }
 
     this->onGpuStencilPath(path, fill);
 }
 
 void GrGpu::finalizeReservedVertices() {
-    GrAssert(NULL != fVertexPool);
+    SkASSERT(NULL != fVertexPool);
     fVertexPool->unlock();
 }
 
 void GrGpu::finalizeReservedIndices() {
-    GrAssert(NULL != fIndexPool);
+    SkASSERT(NULL != fIndexPool);
     fIndexPool->unlock();
 }
 
 void GrGpu::prepareVertexPool() {
     if (NULL == fVertexPool) {
-        GrAssert(0 == fVertexPoolUseCnt);
+        SkASSERT(0 == fVertexPoolUseCnt);
         fVertexPool = SkNEW_ARGS(GrVertexBufferAllocPool, (this, true,
                                                   VERTEX_POOL_VB_SIZE,
                                                   VERTEX_POOL_VB_COUNT));
         fVertexPool->releaseGpuRef();
     } else if (!fVertexPoolUseCnt) {
         // the client doesn't have valid data in the pool
         fVertexPool->reset();
     }
 }
 
 void GrGpu::prepareIndexPool() {
     if (NULL == fIndexPool) {
-        GrAssert(0 == fIndexPoolUseCnt);
+        SkASSERT(0 == fIndexPoolUseCnt);
         fIndexPool = SkNEW_ARGS(GrIndexBufferAllocPool, (this, true,
                                                 INDEX_POOL_IB_SIZE,
                                                 INDEX_POOL_IB_COUNT));
         fIndexPool->releaseGpuRef();
     } else if (!fIndexPoolUseCnt) {
         // the client doesn't have valid data in the pool
         fIndexPool->reset();
     }
 }
 
 bool GrGpu::onReserveVertexSpace(size_t vertexSize,
                                  int vertexCount,
                                  void** vertices) {
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
 
-    GrAssert(vertexCount > 0);
-    GrAssert(NULL != vertices);
+    SkASSERT(vertexCount > 0);
+    SkASSERT(NULL != vertices);
 
     this->prepareVertexPool();
 
     *vertices = fVertexPool->makeSpace(vertexSize,
                                        vertexCount,
                                        &geomPoolState.fPoolVertexBuffer,
                                        &geomPoolState.fPoolStartVertex);
     if (NULL == *vertices) {
         return false;
     }
     ++fVertexPoolUseCnt;
     return true;
 }
 
 bool GrGpu::onReserveIndexSpace(int indexCount, void** indices) {
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
 
-    GrAssert(indexCount > 0);
-    GrAssert(NULL != indices);
+    SkASSERT(indexCount > 0);
+    SkASSERT(NULL != indices);
 
     this->prepareIndexPool();
 
     *indices = fIndexPool->makeSpace(indexCount,
                                      &geomPoolState.fPoolIndexBuffer,
                                      &geomPoolState.fPoolStartIndex);
     if (NULL == *indices) {
         return false;
     }
     ++fIndexPoolUseCnt;
     return true;
 }
 
 void GrGpu::releaseReservedVertexSpace() {
     const GeometrySrcState& geoSrc = this->getGeomSrc();
-    GrAssert(kReserved_GeometrySrcType == geoSrc.fVertexSrc);
+    SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc);
     size_t bytes = geoSrc.fVertexCount * geoSrc.fVertexSize;
     fVertexPool->putBack(bytes);
     --fVertexPoolUseCnt;
 }
 
 void GrGpu::releaseReservedIndexSpace() {
     const GeometrySrcState& geoSrc = this->getGeomSrc();
-    GrAssert(kReserved_GeometrySrcType == geoSrc.fIndexSrc);
+    SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc);
     size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
     fIndexPool->putBack(bytes);
     --fIndexPoolUseCnt;
 }
 
 void GrGpu::onSetVertexSourceToArray(const void* vertexArray, int vertexCount) {
     this->prepareVertexPool();
     GeometryPoolState& geomPoolState = fGeomPoolStateStack.back();
 #if GR_DEBUG
     bool success =
@@ skipping 17 matching lines @@
                               indexArray,
                               &geomPoolState.fPoolIndexBuffer,
                               &geomPoolState.fPoolStartIndex);
     ++fIndexPoolUseCnt;
     GR_DEBUGASSERT(success);
 }
 
 void GrGpu::releaseVertexArray() {
     // if vertex source was array, we stowed data in the pool
     const GeometrySrcState& geoSrc = this->getGeomSrc();
-    GrAssert(kArray_GeometrySrcType == geoSrc.fVertexSrc);
+    SkASSERT(kArray_GeometrySrcType == geoSrc.fVertexSrc);
     size_t bytes = geoSrc.fVertexCount * geoSrc.fVertexSize;
     fVertexPool->putBack(bytes);
     --fVertexPoolUseCnt;
 }
 
 void GrGpu::releaseIndexArray() {
     // if index source was array, we stowed data in the pool
     const GeometrySrcState& geoSrc = this->getGeomSrc();
-    GrAssert(kArray_GeometrySrcType == geoSrc.fIndexSrc);
+    SkASSERT(kArray_GeometrySrcType == geoSrc.fIndexSrc);
     size_t bytes = geoSrc.fIndexCount * sizeof(uint16_t);
     fIndexPool->putBack(bytes);
     --fIndexPoolUseCnt;
 }