Replace uses of GrAssert by SkASSERT.

src/gpu/GrDrawTarget.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.
  */
 
 
 
@@ skipping 15 matching lines @@
     fStartVertex    = di.fStartVertex;
     fStartIndex     = di.fStartIndex;
     fVertexCount    = di.fVertexCount;
     fIndexCount     = di.fIndexCount;
 
     fInstanceCount          = di.fInstanceCount;
     fVerticesPerInstance    = di.fVerticesPerInstance;
     fIndicesPerInstance     = di.fIndicesPerInstance;
 
     if (NULL != di.fDevBounds) {
-        GrAssert(di.fDevBounds == &di.fDevBoundsStorage);
+        SkASSERT(di.fDevBounds == &di.fDevBoundsStorage);
         fDevBoundsStorage = di.fDevBoundsStorage;
         fDevBounds = &fDevBoundsStorage;
     } else {
         fDevBounds = NULL;
     }
 
     fDstCopy = di.fDstCopy;
 
     return *this;
 }
 
 #if GR_DEBUG
 bool GrDrawTarget::DrawInfo::isInstanced() const {
     if (fInstanceCount > 0) {
-        GrAssert(0 == fIndexCount % fIndicesPerInstance);
-        GrAssert(0 == fVertexCount % fVerticesPerInstance);
-        GrAssert(fIndexCount / fIndicesPerInstance == fInstanceCount);
-        GrAssert(fVertexCount / fVerticesPerInstance == fInstanceCount);
+        SkASSERT(0 == fIndexCount % fIndicesPerInstance);
+        SkASSERT(0 == fVertexCount % fVerticesPerInstance);
+        SkASSERT(fIndexCount / fIndicesPerInstance == fInstanceCount);
+        SkASSERT(fVertexCount / fVerticesPerInstance == fInstanceCount);
         // there is no way to specify a non-zero start index to drawIndexedInstances().
-        GrAssert(0 == fStartIndex);
+        SkASSERT(0 == fStartIndex);
         return true;
     } else {
-        GrAssert(!fVerticesPerInstance);
-        GrAssert(!fIndicesPerInstance);
+        SkASSERT(!fVerticesPerInstance);
+        SkASSERT(!fIndicesPerInstance);
         return false;
     }
 }
 #endif
 
 void GrDrawTarget::DrawInfo::adjustInstanceCount(int instanceOffset) {
-    GrAssert(this->isInstanced());
-    GrAssert(instanceOffset + fInstanceCount >= 0);
+    SkASSERT(this->isInstanced());
+    SkASSERT(instanceOffset + fInstanceCount >= 0);
     fInstanceCount += instanceOffset;
     fVertexCount = fVerticesPerInstance * fInstanceCount;
     fIndexCount = fIndicesPerInstance * fInstanceCount;
 }
 
 void GrDrawTarget::DrawInfo::adjustStartVertex(int vertexOffset) {
     fStartVertex += vertexOffset;
-    GrAssert(fStartVertex >= 0);
+    SkASSERT(fStartVertex >= 0);
 }
 
 void GrDrawTarget::DrawInfo::adjustStartIndex(int indexOffset) {
-    GrAssert(this->isIndexed());
+    SkASSERT(this->isIndexed());
     fStartIndex += indexOffset;
-    GrAssert(fStartIndex >= 0);
+    SkASSERT(fStartIndex >= 0);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #define DEBUG_INVAL_BUFFER 0xdeadcafe
 #define DEBUG_INVAL_START_IDX -1
 
 GrDrawTarget::GrDrawTarget(GrContext* context)
     : fClip(NULL)
     , fContext(context) {
-    GrAssert(NULL != context);
+    SkASSERT(NULL != context);
 
     fDrawState = &fDefaultDrawState;
     // We assume that fDrawState always owns a ref to the object it points at.
     fDefaultDrawState.ref();
     GeometrySrcState& geoSrc = fGeoSrcStateStack.push_back();
 #if GR_DEBUG
     geoSrc.fVertexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fVertexBuffer = (GrVertexBuffer*)DEBUG_INVAL_BUFFER;
     geoSrc.fIndexCount = DEBUG_INVAL_START_IDX;
     geoSrc.fIndexBuffer = (GrIndexBuffer*)DEBUG_INVAL_BUFFER;
 #endif
     geoSrc.fVertexSrc = kNone_GeometrySrcType;
     geoSrc.fIndexSrc  = kNone_GeometrySrcType;
 }
 
 GrDrawTarget::~GrDrawTarget() {
-    GrAssert(1 == fGeoSrcStateStack.count());
+    SkASSERT(1 == fGeoSrcStateStack.count());
     SkDEBUGCODE(GeometrySrcState& geoSrc = fGeoSrcStateStack.back());
-    GrAssert(kNone_GeometrySrcType == geoSrc.fIndexSrc);
-    GrAssert(kNone_GeometrySrcType == geoSrc.fVertexSrc);
+    SkASSERT(kNone_GeometrySrcType == geoSrc.fIndexSrc);
+    SkASSERT(kNone_GeometrySrcType == geoSrc.fVertexSrc);
     fDrawState->unref();
 }
 
 void GrDrawTarget::releaseGeometry() {
     int popCnt = fGeoSrcStateStack.count() - 1;
     while (popCnt) {
         this->popGeometrySource();
         --popCnt;
     }
     this->resetVertexSource();
     this->resetIndexSource();
 }
 
 void GrDrawTarget::setClip(const GrClipData* clip) {
     clipWillBeSet(clip);
     fClip = clip;
 }
 
 const GrClipData* GrDrawTarget::getClip() const {
     return fClip;
 }
 
 void GrDrawTarget::setDrawState(GrDrawState*  drawState) {
-    GrAssert(NULL != fDrawState);
+    SkASSERT(NULL != fDrawState);
     if (NULL == drawState) {
         drawState = &fDefaultDrawState;
     }
     if (fDrawState != drawState) {
         fDrawState->unref();
         drawState->ref();
         fDrawState = drawState;
     }
 }
 
 bool GrDrawTarget::reserveVertexSpace(size_t vertexSize,
                                       int vertexCount,
                                       void** vertices) {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     bool acquired = false;
     if (vertexCount > 0) {
-        GrAssert(NULL != vertices);
+        SkASSERT(NULL != vertices);
         this->releasePreviousVertexSource();
         geoSrc.fVertexSrc = kNone_GeometrySrcType;
 
         acquired = this->onReserveVertexSpace(vertexSize,
                                               vertexCount,
                                               vertices);
     }
     if (acquired) {
         geoSrc.fVertexSrc = kReserved_GeometrySrcType;
         geoSrc.fVertexCount = vertexCount;
         geoSrc.fVertexSize = vertexSize;
     } else if (NULL != vertices) {
         *vertices = NULL;
     }
     return acquired;
 }
 
 bool GrDrawTarget::reserveIndexSpace(int indexCount,
                                      void** indices) {
     GeometrySrcState& geoSrc = fGeoSrcStateStack.back();
     bool acquired = false;
     if (indexCount > 0) {
-        GrAssert(NULL != indices);
+        SkASSERT(NULL != indices);
         this->releasePreviousIndexSource();
         geoSrc.fIndexSrc = kNone_GeometrySrcType;
 
         acquired = this->onReserveIndexSpace(indexCount, indices);
     }
     if (acquired) {
         geoSrc.fIndexSrc = kReserved_GeometrySrcType;
         geoSrc.fIndexCount = indexCount;
     } else if (NULL != indices) {
         *indices = NULL;
@@ skipping 140 matching lines @@
 #if GR_DEBUG
     newState.fVertexCount  = ~0;
     newState.fVertexBuffer = (GrVertexBuffer*)~0;
     newState.fIndexCount   = ~0;
     newState.fIndexBuffer = (GrIndexBuffer*)~0;
 #endif
 }
 
 void GrDrawTarget::popGeometrySource() {
     // if popping last element then pops are unbalanced with pushes
-    GrAssert(fGeoSrcStateStack.count() > 1);
+    SkASSERT(fGeoSrcStateStack.count() > 1);
 
     this->geometrySourceWillPop(fGeoSrcStateStack.fromBack(1));
     this->releasePreviousVertexSource();
     this->releasePreviousIndexSource();
     fGeoSrcStateStack.pop_back();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::checkDraw(GrPrimitiveType type, int startVertex,
@@ skipping 30 matching lines @@
                 break;
             case kBuffer_GeometrySrcType:
                 maxValidIndex = geoSrc.fIndexBuffer->sizeInBytes() / sizeof(uint16_t);
                 break;
         }
         if (maxIndex > maxValidIndex) {
             GrCrash("Index reads outside valid index range.");
         }
     }
 
-    GrAssert(NULL != drawState.getRenderTarget());
+    SkASSERT(NULL != drawState.getRenderTarget());
 
     for (int s = 0; s < drawState.numColorStages(); ++s) {
         const GrEffectRef& effect = *drawState.getColorStage(s).getEffect();
         int numTextures = effect->numTextures();
         for (int t = 0; t < numTextures; ++t) {
             GrTexture* texture = effect->texture(t);
-            GrAssert(texture->asRenderTarget() != drawState.getRenderTarget());
+            SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
         }
     }
     for (int s = 0; s < drawState.numCoverageStages(); ++s) {
         const GrEffectRef& effect = *drawState.getCoverageStage(s).getEffect();
         int numTextures = effect->numTextures();
         for (int t = 0; t < numTextures; ++t) {
             GrTexture* texture = effect->texture(t);
-            GrAssert(texture->asRenderTarget() != drawState.getRenderTarget());
+            SkASSERT(texture->asRenderTarget() != drawState.getRenderTarget());
         }
     }
 
-    GrAssert(drawState.validateVertexAttribs());
+    SkASSERT(drawState.validateVertexAttribs());
 #endif
     if (NULL == drawState.getRenderTarget()) {
         return false;
     }
     return true;
 }
 
 bool GrDrawTarget::setupDstReadIfNecessary(DrawInfo* info) {
     if (this->caps()->dstReadInShaderSupport() || !this->getDrawState().willEffectReadDstColor()) {
         return true;
@@ skipping 91 matching lines @@
         // TODO: We should continue with incorrect blending.
         if (!this->setupDstReadIfNecessary(&info)) {
             return;
         }
         this->onDraw(info);
     }
 }
 
 void GrDrawTarget::stencilPath(const GrPath* path, const SkStrokeRec& stroke, SkPath::FillType fill) {
     // TODO: extract portions of checkDraw that are relevant to path stenciling.
-    GrAssert(NULL != path);
-    GrAssert(this->caps()->pathStencilingSupport());
-    GrAssert(!stroke.isHairlineStyle());
-    GrAssert(!SkPath::IsInverseFillType(fill));
+    SkASSERT(NULL != path);
+    SkASSERT(this->caps()->pathStencilingSupport());
+    SkASSERT(!stroke.isHairlineStyle());
+    SkASSERT(!SkPath::IsInverseFillType(fill));
     this->onStencilPath(path, stroke, fill);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawTarget::willUseHWAALines() const {
     // There is a conflict between using smooth lines and our use of premultiplied alpha. Smooth
     // lines tweak the incoming alpha value but not in a premul-alpha way. So we only use them when
     // our alpha is 0xff and tweaking the color for partial coverage is OK
     if (!this->caps()->hwAALineSupport() ||
@@ skipping 137 matching lines @@
 }
 
 GrDrawTarget::AutoStateRestore::~AutoStateRestore() {
     if (NULL != fDrawTarget) {
         fDrawTarget->setDrawState(fSavedState);
         fSavedState->unref();
     }
 }
 
 void GrDrawTarget::AutoStateRestore::set(GrDrawTarget* target, ASRInit init, const SkMatrix* vm) {
-    GrAssert(NULL == fDrawTarget);
+    SkASSERT(NULL == fDrawTarget);
     fDrawTarget = target;
     fSavedState = target->drawState();
-    GrAssert(fSavedState);
+    SkASSERT(fSavedState);
     fSavedState->ref();
     if (kReset_ASRInit == init) {
         if (NULL == vm) {
             // calls the default cons
             fTempState.init();
         } else {
             SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*vm));
         }
     } else {
-        GrAssert(kPreserve_ASRInit == init);
+        SkASSERT(kPreserve_ASRInit == init);
         if (NULL == vm) {
             fTempState.set(*fSavedState);
         } else {
             SkNEW_IN_TLAZY(&fTempState, GrDrawState, (*fSavedState, *vm));
         }
     }
     target->setDrawState(fTempState.get());
 }
 
 bool GrDrawTarget::AutoStateRestore::setIdentity(GrDrawTarget* target, ASRInit init) {
-    GrAssert(NULL == fDrawTarget);
+    SkASSERT(NULL == fDrawTarget);
     fDrawTarget = target;
     fSavedState = target->drawState();
-    GrAssert(fSavedState);
+    SkASSERT(fSavedState);
     fSavedState->ref();
     if (kReset_ASRInit == init) {
         // calls the default cons
         fTempState.init();
     } else {
-        GrAssert(kPreserve_ASRInit == init);
+        SkASSERT(kPreserve_ASRInit == init);
         // calls the copy cons
         fTempState.set(*fSavedState);
         if (!fTempState.get()->setIdentityViewMatrix()) {
             // let go of any resources held by the temp
             fTempState.get()->reset();
             fDrawTarget = NULL;
             fSavedState->unref();
             fSavedState = NULL;
             return false;
         }
@@ skipping 30 matching lines @@
         fTarget = target;
         success = target->reserveVertexAndIndexSpace(vertexCount,
                                                      indexCount,
                                                      &fVertices,
                                                      &fIndices);
         if (!success) {
             fTarget = NULL;
             this->reset();
         }
     }
-    GrAssert(success == (NULL != fTarget));
+    SkASSERT(success == (NULL != fTarget));
     return success;
 }
 
 void GrDrawTarget::AutoReleaseGeometry::reset() {
     if (NULL != fTarget) {
         if (NULL != fVertices) {
             fTarget->resetVertexSource();
         }
         if (NULL != fIndices) {
             fTarget->resetIndexSource();
@@ skipping 63 matching lines @@
     // The above clipping steps may have inverted the rect if it didn't intersect either the src or
     // dst bounds.
     return !clippedSrcRect->isEmpty();
 }
 }
 
 bool GrDrawTarget::copySurface(GrSurface* dst,
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) {
-    GrAssert(NULL != dst);
-    GrAssert(NULL != src);
+    SkASSERT(NULL != dst);
+    SkASSERT(NULL != src);
 
     SkIRect clippedSrcRect;
     SkIPoint clippedDstPoint;
     // If the rect is outside the src or dst then we've already succeeded.
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
-        GrAssert(this->canCopySurface(dst, src, srcRect, dstPoint));
+        SkASSERT(this->canCopySurface(dst, src, srcRect, dstPoint));
         return true;
     }
 
     bool result = this->onCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
-    GrAssert(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
+    SkASSERT(result == this->canCopySurface(dst, src, clippedSrcRect, clippedDstPoint));
     return result;
 }
 
 bool GrDrawTarget::canCopySurface(GrSurface* dst,
                                   GrSurface* src,
                                   const SkIRect& srcRect,
                                   const SkIPoint& dstPoint) {
-    GrAssert(NULL != dst);
-    GrAssert(NULL != src);
+    SkASSERT(NULL != dst);
+    SkASSERT(NULL != src);
 
     SkIRect clippedSrcRect;
     SkIPoint clippedDstPoint;
     // If the rect is outside the src or dst then we're guaranteed success
     if (!clip_srcrect_and_dstpoint(dst,
                                    src,
                                    srcRect,
                                    dstPoint,
                                    &clippedSrcRect,
                                    &clippedDstPoint)) {
         return true;
     }
     return this->onCanCopySurface(dst, src, clippedSrcRect, clippedDstPoint);
 }
 
 bool GrDrawTarget::onCanCopySurface(GrSurface* dst,
                                     GrSurface* src,
                                     const SkIRect& srcRect,
                                     const SkIPoint& dstPoint) {
     // Check that the read/write rects are contained within the src/dst bounds.
-    GrAssert(!srcRect.isEmpty());
-    GrAssert(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
-    GrAssert(dstPoint.fX >= 0 && dstPoint.fY >= 0);
-    GrAssert(dstPoint.fX + srcRect.width() <= dst->width() &&
+    SkASSERT(!srcRect.isEmpty());
+    SkASSERT(SkIRect::MakeWH(src->width(), src->height()).contains(srcRect));
+    SkASSERT(dstPoint.fX >= 0 && dstPoint.fY >= 0);
+    SkASSERT(dstPoint.fX + srcRect.width() <= dst->width() &&
              dstPoint.fY + srcRect.height() <= dst->height());
 
     return !dst->isSameAs(src) && NULL != dst->asRenderTarget() && NULL != src->asTexture();
 }
 
 bool GrDrawTarget::onCopySurface(GrSurface* dst,
                                  GrSurface* src,
                                  const SkIRect& srcRect,
                                  const SkIPoint& dstPoint) {
     if (!GrDrawTarget::onCanCopySurface(dst, src, srcRect, dstPoint)) {
@@ skipping 80 matching lines @@
     GrPrintf("Geometry Shader Support     : %s\n", gNY[fGeometryShaderSupport]);
     GrPrintf("Dual Source Blending Support: %s\n", gNY[fDualSourceBlendingSupport]);
     GrPrintf("Buffer Lock Support         : %s\n", gNY[fBufferLockSupport]);
     GrPrintf("Path Stenciling Support     : %s\n", gNY[fPathStencilingSupport]);
     GrPrintf("Dst Read In Shader Support  : %s\n", gNY[fDstReadInShaderSupport]);
     GrPrintf("Reuse Scratch Textures      : %s\n", gNY[fReuseScratchTextures]);
     GrPrintf("Max Texture Size            : %d\n", fMaxTextureSize);
     GrPrintf("Max Render Target Size      : %d\n", fMaxRenderTargetSize);
     GrPrintf("Max Sample Count            : %d\n", fMaxSampleCount);
 }