Replace uses of GrAssert by SkASSERT.

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 #include "GrPaint.h"
 
 bool GrDrawState::setIdentityViewMatrix()  {
     if (fColorStages.count() || fCoverageStages.count()) {
         SkMatrix invVM;
         if (!fCommon.fViewMatrix.invert(&invVM)) {
             // sad trombone sound
             return false;
         }
         for (int s = 0; s < fColorStages.count(); ++s) {
             fColorStages[s].localCoordChange(invVM);
         }
         for (int s = 0; s < fCoverageStages.count(); ++s) {
             fCoverageStages[s].localCoordChange(invVM);
         }
     }
     fCommon.fViewMatrix.reset();
     return true;
 }
 
 void GrDrawState::setFromPaint(const GrPaint& paint, const SkMatrix& vm, GrRenderTarget* rt) {
-    GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
+    SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
 
     fColorStages.reset();
     fCoverageStages.reset();
 
     for (int i = 0; i < paint.numColorStages(); ++i) {
         fColorStages.push_back(paint.getColorStage(i));
     }
 
     for (int i = 0; i < paint.numCoverageStages(); ++i) {
         fCoverageStages.push_back(paint.getCoverageStage(i));
@@ skipping 22 matching lines @@
     this->setCoverage(paint.getCoverage());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 static size_t vertex_size(const GrVertexAttrib* attribs, int count) {
     // this works as long as we're 4 byte-aligned
 #if GR_DEBUG
     uint32_t overlapCheck = 0;
 #endif
-    GrAssert(count <= GrDrawState::kMaxVertexAttribCnt);
+    SkASSERT(count <= GrDrawState::kMaxVertexAttribCnt);
     size_t size = 0;
     for (int index = 0; index < count; ++index) {
         size_t attribSize = GrVertexAttribTypeSize(attribs[index].fType);
         size += attribSize;
 #if GR_DEBUG
         size_t dwordCount = attribSize >> 2;
         uint32_t mask = (1 << dwordCount)-1;
         size_t offsetShift = attribs[index].fOffset >> 2;
-        GrAssert(!(overlapCheck & (mask << offsetShift)));
+        SkASSERT(!(overlapCheck & (mask << offsetShift)));
         overlapCheck |= (mask << offsetShift);
 #endif
     }
     return size;
 }
 
 size_t GrDrawState::getVertexSize() const {
     return vertex_size(fCommon.fVAPtr, fCommon.fVACount);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setVertexAttribs(const GrVertexAttrib* attribs, int count) {
-    GrAssert(count <= kMaxVertexAttribCnt);
+    SkASSERT(count <= kMaxVertexAttribCnt);
 
     fCommon.fVAPtr = attribs;
     fCommon.fVACount = count;
 
     // Set all the indices to -1
     memset(fCommon.fFixedFunctionVertexAttribIndices,
            0xff,
            sizeof(fCommon.fFixedFunctionVertexAttribIndices));
 #if GR_DEBUG
     uint32_t overlapCheck = 0;
 #endif
     for (int i = 0; i < count; ++i) {
         if (attribs[i].fBinding < kGrFixedFunctionVertexAttribBindingCnt) {
             // The fixed function attribs can only be specified once
-            GrAssert(-1 == fCommon.fFixedFunctionVertexAttribIndices[attribs[i].fBinding]);
-            GrAssert(GrFixedFunctionVertexAttribVectorCount(attribs[i].fBinding) ==
+            SkASSERT(-1 == fCommon.fFixedFunctionVertexAttribIndices[attribs[i].fBinding]);
+            SkASSERT(GrFixedFunctionVertexAttribVectorCount(attribs[i].fBinding) ==
                      GrVertexAttribTypeVectorCount(attribs[i].fType));
             fCommon.fFixedFunctionVertexAttribIndices[attribs[i].fBinding] = i;
         }
 #if GR_DEBUG
         size_t dwordCount = GrVertexAttribTypeSize(attribs[i].fType) >> 2;
         uint32_t mask = (1 << dwordCount)-1;
         size_t offsetShift = attribs[i].fOffset >> 2;
-        GrAssert(!(overlapCheck & (mask << offsetShift)));
+        SkASSERT(!(overlapCheck & (mask << offsetShift)));
         overlapCheck |= (mask << offsetShift);
 #endif
     }
     // Positions must be specified.
-    GrAssert(-1 != fCommon.fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]);
+    SkASSERT(-1 != fCommon.fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setDefaultVertexAttribs() {
     static const GrVertexAttrib kPositionAttrib =
         {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding};
 
     fCommon.fVAPtr = &kPositionAttrib;
     fCommon.fVACount = 1;
@@ skipping 11 matching lines @@
     // check consistency of effects and attributes
     GrSLType slTypes[kMaxVertexAttribCnt];
     for (int i = 0; i < kMaxVertexAttribCnt; ++i) {
         slTypes[i] = static_cast<GrSLType>(-1);
     }
     int totalStages = fColorStages.count() + fCoverageStages.count();
     for (int s = 0; s < totalStages; ++s) {
         int covIdx = s - fColorStages.count();
         const GrEffectStage& stage = covIdx < 0 ? fColorStages[s] : fCoverageStages[covIdx];
         const GrEffectRef* effect = stage.getEffect();
-        GrAssert(NULL != effect);
+        SkASSERT(NULL != effect);
         // make sure that any attribute indices have the correct binding type, that the attrib
         // type and effect's shader lang type are compatible, and that attributes shared by
         // multiple effects use the same shader lang type.
         const int* attributeIndices = stage.getVertexAttribIndices();
         int numAttributes = stage.getVertexAttribIndexCount();
         for (int i = 0; i < numAttributes; ++i) {
             int attribIndex = attributeIndices[i];
             if (attribIndex >= fCommon.fVACount ||
                 kEffect_GrVertexAttribBinding != fCommon.fVAPtr[attribIndex].fBinding) {
                 return false;
@@ skipping 227 matching lines @@
     }
     return kNone_BlendOpt;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::AutoViewMatrixRestore::restore() {
     if (NULL != fDrawState) {
         GR_DEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
         fDrawState->fCommon.fViewMatrix = fViewMatrix;
-        GrAssert(fDrawState->numColorStages() >= fNumColorStages);
+        SkASSERT(fDrawState->numColorStages() >= fNumColorStages);
         int numCoverageStages = fSavedCoordChanges.count() - fNumColorStages;
-        GrAssert(fDrawState->numCoverageStages() >= numCoverageStages);
+        SkASSERT(fDrawState->numCoverageStages() >= numCoverageStages);
 
         int i = 0;
         for (int s = 0; s < fNumColorStages; ++s, ++i) {
             fDrawState->fColorStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         for (int s = 0; s < numCoverageStages; ++s, ++i) {
             fDrawState->fCoverageStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         fDrawState = NULL;
     }
 }
 
 void GrDrawState::AutoViewMatrixRestore::set(GrDrawState* drawState,
                                              const SkMatrix& preconcatMatrix) {
     this->restore();
 
-    GrAssert(NULL == fDrawState);
+    SkASSERT(NULL == fDrawState);
     if (NULL == drawState || preconcatMatrix.isIdentity()) {
         return;
     }
     fDrawState = drawState;
 
     fViewMatrix = drawState->getViewMatrix();
     drawState->fCommon.fViewMatrix.preConcat(preconcatMatrix);
 
     this->doEffectCoordChanges(preconcatMatrix);
     GR_DEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
@@ skipping 40 matching lines @@
         fDrawState->fColorStages[s].saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fColorStages[s].localCoordChange(coordChangeMatrix);
     }
 
     int numCoverageStages = fDrawState->numCoverageStages();
     for (int s = 0; s < numCoverageStages; ++s, ++i) {
         fDrawState->fCoverageStages[s].saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fCoverageStages[s].localCoordChange(coordChangeMatrix);
     }
 }