Replace uses of GrAssert by SkASSERT.

src/gpu/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 223 matching lines @@
     target->drawState()->setDefaultVertexAttribs();
     if (!arg->set(target, maxPts, maxIdxs)) {
         return false;
     }
 
     uint16_t* idxBase = reinterpret_cast<uint16_t*>(arg->indices());
     uint16_t* idx = idxBase;
     uint16_t subpathIdxStart = 0;
 
     GrPoint* base = reinterpret_cast<GrPoint*>(arg->vertices());
-    GrAssert(NULL != base);
+    SkASSERT(NULL != base);
     GrPoint* vert = base;
 
     GrPoint pts[4];
 
     bool first = true;
     int subpath = 0;
 
     SkPath::Iter iter(path, false);
 
     for (;;) {
@@ skipping 52 matching lines @@
             }
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kDone_Verb:
              // uint16_t currIdx = (uint16_t) (vert - base);
                 goto FINISHED;
         }
         first = false;
     }
 FINISHED:
-    GrAssert((vert - base) <= maxPts);
-    GrAssert((idx - idxBase) <= maxIdxs);
+    SkASSERT((vert - base) <= maxPts);
+    SkASSERT((idx - idxBase) <= maxIdxs);
 
     *vertexCnt = vert - base;
     *indexCnt = idx - idxBase;
 
     }
     return true;
 }
 
 bool GrDefaultPathRenderer::internalDrawPath(const SkPath& path,
                                              const SkStrokeRec& stroke,
@@ skipping 12 matching lines @@
                           stroke,
                           tol,
                           target,
                           &primType,
                           &vertexCnt,
                           &indexCnt,
                           &arg)) {
         return false;
     }
 
-    GrAssert(NULL != target);
+    SkASSERT(NULL != target);
     GrDrawTarget::AutoStateRestore asr(target, GrDrawTarget::kPreserve_ASRInit);
     GrDrawState* drawState = target->drawState();
     bool colorWritesWereDisabled = drawState->isColorWriteDisabled();
     // face culling doesn't make sense here
-    GrAssert(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
+    SkASSERT(GrDrawState::kBoth_DrawFace == drawState->getDrawFace());
 
     int                         passCount = 0;
     const GrStencilSettings*    passes[3];
     GrDrawState::DrawFace       drawFace[3];
     bool                        reverse = false;
     bool                        lastPassIsBounds;
 
     if (stroke.isHairlineStyle()) {
         passCount = 1;
         if (stencilOnly) {
@@ skipping 67 matching lines @@
                         lastPassIsBounds = true;
                         drawFace[passCount-1] = GrDrawState::kBoth_DrawFace;
                         if (reverse) {
                             passes[passCount-1] = &gInvWindColorPass;
                         } else {
                             passes[passCount-1] = &gWindColorPass;
                         }
                     }
                     break;
                 default:
-                    GrAssert(!"Unknown path fFill!");
+                    SkASSERT(!"Unknown path fFill!");
                     return false;
             }
         }
     }
 
     SkRect devBounds;
     GetPathDevBounds(path, drawState->getRenderTarget(), viewM, &devBounds);
 
     for (int p = 0; p < passCount; ++p) {
         drawState->setDrawFace(drawFace[p]);
         if (NULL != passes[p]) {
             *drawState->stencil() = *passes[p];
         }
 
         if (lastPassIsBounds && (p == passCount-1)) {
             if (!colorWritesWereDisabled) {
                 drawState->disableState(GrDrawState::kNoColorWrites_StateBit);
             }
             SkRect bounds;
             GrDrawState::AutoViewMatrixRestore avmr;
             if (reverse) {
-                GrAssert(NULL != drawState->getRenderTarget());
+                SkASSERT(NULL != drawState->getRenderTarget());
                 // draw over the dev bounds (which will be the whole dst surface for inv fill).
                 bounds = devBounds;
                 SkMatrix vmi;
                 // mapRect through persp matrix may not be correct
                 if (!drawState->getViewMatrix().hasPerspective() &&
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     avmr.setIdentity(drawState);
                 }
@@ skipping 31 matching lines @@
                                        bool antiAlias) {
     return this->internalDrawPath(path,
                                   stroke,
                                   target,
                                   false);
 }
 
 void GrDefaultPathRenderer::onStencilPath(const SkPath& path,
                                           const SkStrokeRec& stroke,
                                           GrDrawTarget* target) {
-    GrAssert(SkPath::kInverseEvenOdd_FillType != path.getFillType());
-    GrAssert(SkPath::kInverseWinding_FillType != path.getFillType());
+    SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
+    SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(path, stroke, target, true);
 }