Replace uses of GrAssert by SkASSERT.

src/gpu/GrInOrderDrawBuffer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrInOrderDrawBuffer.h"
 
 #include "GrBufferAllocPool.h"
@@ skipping 15 matching lines @@
     , fClipSet(true)
     , fClipProxyState(kUnknown_ClipProxyState)
     , fVertexPool(*vertexPool)
     , fIndexPool(*indexPool)
     , fFlushing(false)
     , fDrawID(0) {
 
     fDstGpu->ref();
     fCaps.reset(SkRef(fDstGpu->caps()));
 
-    GrAssert(NULL != vertexPool);
-    GrAssert(NULL != indexPool);
+    SkASSERT(NULL != vertexPool);
+    SkASSERT(NULL != indexPool);
 
     GeometryPoolState& poolState = fGeoPoolStateStack.push_back();
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fUsedPoolIndexBytes = 0;
 #if GR_DEBUG
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
     poolState.fPoolStartVertex = ~0;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
     poolState.fPoolStartIndex = ~0;
 #endif
     this->reset();
 }
 
 GrInOrderDrawBuffer::~GrInOrderDrawBuffer() {
     this->reset();
     // This must be called by before the GrDrawTarget destructor
     this->releaseGeometry();
     fDstGpu->unref();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 void get_vertex_bounds(const void* vertices,
                        size_t vertexSize,
                        int vertexCount,
                        SkRect* bounds) {
-    GrAssert(vertexSize >= sizeof(GrPoint));
-    GrAssert(vertexCount > 0);
+    SkASSERT(vertexSize >= sizeof(GrPoint));
+    SkASSERT(vertexCount > 0);
     const GrPoint* point = static_cast<const GrPoint*>(vertices);
     bounds->fLeft = bounds->fRight = point->fX;
     bounds->fTop = bounds->fBottom = point->fY;
     for (int i = 1; i < vertexCount; ++i) {
         point = reinterpret_cast<GrPoint*>(reinterpret_cast<intptr_t>(point) + vertexSize);
         bounds->growToInclude(point->fX, point->fY);
     }
 }
 }
 
@@ skipping 112 matching lines @@
         for (int i = 0; i < 4; ++i) {
             *vertColor = color;
             vertColor = (GrColor*) ((intptr_t) vertColor + vsize);
         }
     }
 
     this->setIndexSourceToBuffer(this->getContext()->getQuadIndexBuffer());
     this->drawIndexedInstances(kTriangles_GrPrimitiveType, 1, 4, 6, &devBounds);
 
     // to ensure that stashing the drawState ptr is valid
-    GrAssert(this->drawState() == drawState);
+    SkASSERT(this->drawState() == drawState);
 }
 
 bool GrInOrderDrawBuffer::quickInsideClip(const SkRect& devBounds) {
     if (!this->getDrawState().isClipState()) {
         return true;
     }
     if (kUnknown_ClipProxyState == fClipProxyState) {
         SkIRect rect;
         bool iior;
         this->getClip()->getConservativeBounds(this->getDrawState().getRenderTarget(), &rect, &iior);
@@ skipping 25 matching lines @@
         return fClipProxy.contains(devBounds);
     }
     SkPoint originOffset = {SkIntToScalar(this->getClip()->fOrigin.fX),
                             SkIntToScalar(this->getClip()->fOrigin.fY)};
     SkRect clipSpaceBounds = devBounds;
     clipSpaceBounds.offset(originOffset);
     return this->getClip()->fClipStack->quickContains(clipSpaceBounds);
 }
 
 int GrInOrderDrawBuffer::concatInstancedDraw(const DrawInfo& info) {
-    GrAssert(info.isInstanced());
+    SkASSERT(info.isInstanced());
 
     const GeometrySrcState& geomSrc = this->getGeomSrc();
     const GrDrawState& drawState = this->getDrawState();
 
     // we only attempt to concat the case when reserved verts are used with a client-specified index
     // buffer. To make this work with client-specified VBs we'd need to know if the VB was updated
     // between draws.
     if (kReserved_GeometrySrcType != geomSrc.fVertexSrc ||
         kBuffer_GeometrySrcType != geomSrc.fIndexSrc) {
         return 0;
@@ skipping 15 matching lines @@
         draw->fIndexBuffer != geomSrc.fIndexBuffer) {
         return 0;
     }
     // info does not yet account for the offset from the start of the pool's VB while the previous
     // draw record does.
     int adjustedStartVertex = poolState.fPoolStartVertex + info.startVertex();
     if (draw->startVertex() + draw->vertexCount() != adjustedStartVertex) {
         return 0;
     }
 
-    GrAssert(poolState.fPoolStartVertex == draw->startVertex() + draw->vertexCount());
+    SkASSERT(poolState.fPoolStartVertex == draw->startVertex() + draw->vertexCount());
 
     // how many instances can be concat'ed onto draw given the size of the index buffer
     int instancesToConcat = this->indexCountInCurrentSource() / info.indicesPerInstance();
     instancesToConcat -= draw->instanceCount();
     instancesToConcat = GrMin(instancesToConcat, info.instanceCount());
 
     // update the amount of reserved vertex data actually referenced in draws
     size_t vertexBytes = instancesToConcat * info.verticesPerInstance() *
                          drawState.getVertexSize();
     poolState.fUsedPoolVertexBytes = GrMax(poolState.fUsedPoolVertexBytes, vertexBytes);
@@ skipping 107 matching lines @@
     sp->fPath.reset(path);
     path->ref();
     sp->fFill = fill;
     sp->fStroke = stroke;
 }
 
 void GrInOrderDrawBuffer::clear(const SkIRect* rect, GrColor color, GrRenderTarget* renderTarget) {
     SkIRect r;
     if (NULL == renderTarget) {
         renderTarget = this->drawState()->getRenderTarget();
-        GrAssert(NULL != renderTarget);
+        SkASSERT(NULL != renderTarget);
     }
     if (NULL == rect) {
         // We could do something smart and remove previous draws and clears to
         // the current render target. If we get that smart we have to make sure
         // those draws aren't read before this clear (render-to-texture).
         r.setLTRB(0, 0, renderTarget->width(), renderTarget->height());
         rect = &r;
     }
     Clear* clr = this->recordClear();
     clr->fColor = color;
     clr->fRect = *rect;
     clr->fRenderTarget = renderTarget;
     renderTarget->ref();
 }
 
 void GrInOrderDrawBuffer::reset() {
-    GrAssert(1 == fGeoPoolStateStack.count());
+    SkASSERT(1 == fGeoPoolStateStack.count());
     this->resetVertexSource();
     this->resetIndexSource();
     int numDraws = fDraws.count();
     for (int d = 0; d < numDraws; ++d) {
         // we always have a VB, but not always an IB
-        GrAssert(NULL != fDraws[d].fVertexBuffer);
+        SkASSERT(NULL != fDraws[d].fVertexBuffer);
         fDraws[d].fVertexBuffer->unref();
         GrSafeUnref(fDraws[d].fIndexBuffer);
     }
     fCmds.reset();
     fDraws.reset();
     fStencilPaths.reset();
     fStates.reset();
     fClears.reset();
     fVertexPool.reset();
     fIndexPool.reset();
     fClips.reset();
     fClipOrigins.reset();
     fCopySurfaces.reset();
     fClipSet = true;
 }
 
 void GrInOrderDrawBuffer::flush() {
     if (fFlushing) {
         return;
     }
 
-    GrAssert(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
-    GrAssert(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
+    SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fVertexSrc);
+    SkASSERT(kReserved_GeometrySrcType != this->getGeomSrc().fIndexSrc);
 
     int numCmds = fCmds.count();
     if (0 == numCmds) {
         return;
     }
 
     GrAutoTRestore<bool> flushRestore(&fFlushing);
     fFlushing = true;
 
     fVertexPool.unlock();
@@ skipping 54 matching lines @@
             case kCopySurface_Cmd:
                 fDstGpu->copySurface(fCopySurfaces[currCopySurface].fDst.get(),
                                      fCopySurfaces[currCopySurface].fSrc.get(),
                                      fCopySurfaces[currCopySurface].fSrcRect,
                                      fCopySurfaces[currCopySurface].fDstPoint);
                 ++currCopySurface;
                 break;
         }
     }
     // we should have consumed all the states, clips, etc.
-    GrAssert(fStates.count() == currState);
-    GrAssert(fClips.count() == currClip);
-    GrAssert(fClipOrigins.count() == currClip);
-    GrAssert(fClears.count() == currClear);
-    GrAssert(fDraws.count()  == currDraw);
-    GrAssert(fCopySurfaces.count() == currCopySurface);
+    SkASSERT(fStates.count() == currState);
+    SkASSERT(fClips.count() == currClip);
+    SkASSERT(fClipOrigins.count() == currClip);
+    SkASSERT(fClears.count() == currClear);
+    SkASSERT(fDraws.count()  == currDraw);
+    SkASSERT(fCopySurfaces.count() == currCopySurface);
 
     fDstGpu->setDrawState(prevDrawState);
     prevDrawState->unref();
     this->reset();
     ++fDrawID;
 }
 
 bool GrInOrderDrawBuffer::onCopySurface(GrSurface* dst,
                                         GrSurface* src,
                                         const SkIRect& srcRect,
@@ skipping 84 matching lines @@
         }
         *vertexCount = currVertices;
     }
     return flush;
 }
 
 bool GrInOrderDrawBuffer::onReserveVertexSpace(size_t vertexSize,
                                                int vertexCount,
                                                void** vertices) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
-    GrAssert(vertexCount > 0);
-    GrAssert(NULL != vertices);
-    GrAssert(0 == poolState.fUsedPoolVertexBytes);
+    SkASSERT(vertexCount > 0);
+    SkASSERT(NULL != vertices);
+    SkASSERT(0 == poolState.fUsedPoolVertexBytes);
 
     *vertices = fVertexPool.makeSpace(vertexSize,
                                       vertexCount,
                                       &poolState.fPoolVertexBuffer,
                                       &poolState.fPoolStartVertex);
     return NULL != *vertices;
 }
 
 bool GrInOrderDrawBuffer::onReserveIndexSpace(int indexCount, void** indices) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
-    GrAssert(indexCount > 0);
-    GrAssert(NULL != indices);
-    GrAssert(0 == poolState.fUsedPoolIndexBytes);
+    SkASSERT(indexCount > 0);
+    SkASSERT(NULL != indices);
+    SkASSERT(0 == poolState.fUsedPoolIndexBytes);
 
     *indices = fIndexPool.makeSpace(indexCount,
                                     &poolState.fPoolIndexBuffer,
                                     &poolState.fPoolStartIndex);
     return NULL != *indices;
 }
 
 void GrInOrderDrawBuffer::releaseReservedVertexSpace() {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GeometrySrcState& geoSrc = this->getGeomSrc();
 
     // If we get a release vertex space call then our current source should either be reserved
     // or array (which we copied into reserved space).
-    GrAssert(kReserved_GeometrySrcType == geoSrc.fVertexSrc ||
+    SkASSERT(kReserved_GeometrySrcType == geoSrc.fVertexSrc ||
              kArray_GeometrySrcType == geoSrc.fVertexSrc);
 
     // When the caller reserved vertex buffer space we gave it back a pointer
     // provided by the vertex buffer pool. At each draw we tracked the largest
     // offset into the pool's pointer that was referenced. Now we return to the
     // pool any portion at the tail of the allocation that no draw referenced.
     size_t reservedVertexBytes = geoSrc.fVertexSize * geoSrc.fVertexCount;
     fVertexPool.putBack(reservedVertexBytes -
                         poolState.fUsedPoolVertexBytes);
     poolState.fUsedPoolVertexBytes = 0;
     poolState.fPoolVertexBuffer = NULL;
     poolState.fPoolStartVertex = 0;
 }
 
 void GrInOrderDrawBuffer::releaseReservedIndexSpace() {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     const GeometrySrcState& geoSrc = this->getGeomSrc();
 
     // If we get a release index space call then our current source should either be reserved
     // or array (which we copied into reserved space).
-    GrAssert(kReserved_GeometrySrcType == geoSrc.fIndexSrc ||
+    SkASSERT(kReserved_GeometrySrcType == geoSrc.fIndexSrc ||
              kArray_GeometrySrcType == geoSrc.fIndexSrc);
 
     // Similar to releaseReservedVertexSpace we return any unused portion at
     // the tail
     size_t reservedIndexBytes = sizeof(uint16_t) * geoSrc.fIndexCount;
     fIndexPool.putBack(reservedIndexBytes - poolState.fUsedPoolIndexBytes);
     poolState.fUsedPoolIndexBytes = 0;
     poolState.fPoolIndexBuffer = NULL;
     poolState.fPoolStartIndex = 0;
 }
 
 void GrInOrderDrawBuffer::onSetVertexSourceToArray(const void* vertexArray,
                                                    int vertexCount) {
 
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
-    GrAssert(0 == poolState.fUsedPoolVertexBytes);
+    SkASSERT(0 == poolState.fUsedPoolVertexBytes);
 #if GR_DEBUG
     bool success =
 #endif
     fVertexPool.appendVertices(this->getVertexSize(),
                                vertexCount,
                                vertexArray,
                                &poolState.fPoolVertexBuffer,
                                &poolState.fPoolStartVertex);
     GR_DEBUGASSERT(success);
 }
 
 void GrInOrderDrawBuffer::onSetIndexSourceToArray(const void* indexArray,
                                                   int indexCount) {
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
-    GrAssert(0 == poolState.fUsedPoolIndexBytes);
+    SkASSERT(0 == poolState.fUsedPoolIndexBytes);
 #if GR_DEBUG
     bool success =
 #endif
     fIndexPool.appendIndices(indexCount,
                              indexArray,
                              &poolState.fPoolIndexBuffer,
                              &poolState.fPoolStartIndex);
     GR_DEBUGASSERT(success);
 }
 
@@ skipping 16 matching lines @@
 #if GR_DEBUG
     poolState.fPoolVertexBuffer = (GrVertexBuffer*)~0;
     poolState.fPoolStartVertex = ~0;
     poolState.fPoolIndexBuffer = (GrIndexBuffer*)~0;
     poolState.fPoolStartIndex = ~0;
 #endif
 }
 
 void GrInOrderDrawBuffer::geometrySourceWillPop(
                                         const GeometrySrcState& restoredState) {
-    GrAssert(fGeoPoolStateStack.count() > 1);
+    SkASSERT(fGeoPoolStateStack.count() > 1);
     fGeoPoolStateStack.pop_back();
     GeometryPoolState& poolState = fGeoPoolStateStack.back();
     // we have to assume that any slack we had in our vertex/index data
     // is now unreleasable because data may have been appended later in the
     // pool.
     if (kReserved_GeometrySrcType == restoredState.fVertexSrc ||
         kArray_GeometrySrcType == restoredState.fVertexSrc) {
         poolState.fUsedPoolVertexBytes = restoredState.fVertexSize * restoredState.fVertexCount;
     }
     if (kReserved_GeometrySrcType == restoredState.fIndexSrc ||
         kArray_GeometrySrcType == restoredState.fIndexSrc) {
         poolState.fUsedPoolIndexBytes = sizeof(uint16_t) *
                                          restoredState.fIndexCount;
     }
 }
 
 bool GrInOrderDrawBuffer::needsNewState() const {
     return fStates.empty() || !fStates.back().isEqual(this->getDrawState());
 }
 
 bool GrInOrderDrawBuffer::needsNewClip() const {
-    GrAssert(fClips.count() == fClipOrigins.count());
+    SkASSERT(fClips.count() == fClipOrigins.count());
     if (this->getDrawState().isClipState()) {
        if (fClipSet &&
            (fClips.empty() ||
             fClips.back() != *this->getClip()->fClipStack ||
             fClipOrigins.back() != this->getClip()->fOrigin)) {
            return true;
        }
     }
     return false;
 }
@@ skipping 29 matching lines @@
     fCmds.push_back(kCopySurface_Cmd);
     return &fCopySurfaces.push_back();
 }
 
 
 void GrInOrderDrawBuffer::clipWillBeSet(const GrClipData* newClipData) {
     INHERITED::clipWillBeSet(newClipData);
     fClipSet = true;
     fClipProxyState = kUnknown_ClipProxyState;
 }