Replace uses of GrAssert by SkASSERT.

src/gpu/GrAAConvexPathRenderer.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 "GrAAConvexPathRenderer.h"
 
@@ skipping 85 matching lines @@
         avg.scale(denom);
         *c = avg;
     } else {
         area *= 3;
         area = SkScalarDiv(SK_Scalar1, area);
         center.fX = SkScalarMul(center.fX, area);
         center.fY = SkScalarMul(center.fY, area);
         // undo the translate of p0 to the origin.
         *c = center + p0;
     }
-    GrAssert(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
+    SkASSERT(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
 }
 
 static void compute_vectors(SegmentArray* segments,
                             SkPoint* fanPt,
                             SkPath::Direction dir,
                             int* vCount,
                             int* iCount) {
     center_of_mass(*segments, fanPt);
     int count = segments->count();
 
@@ skipping 85 matching lines @@
         default:
             GrCrash("Unexpected degenerate test stage.");
     }
 }
 
 static inline bool get_direction(const SkPath& path, const SkMatrix& m, SkPath::Direction* dir) {
     if (!path.cheapComputeDirection(dir)) {
         return false;
     }
     // check whether m reverses the orientation
-    GrAssert(!m.hasPerspective());
+    SkASSERT(!m.hasPerspective());
     SkScalar det2x2 = SkScalarMul(m.get(SkMatrix::kMScaleX), m.get(SkMatrix::kMScaleY)) -
                       SkScalarMul(m.get(SkMatrix::kMSkewX), m.get(SkMatrix::kMSkewY));
     if (det2x2 < 0) {
         *dir = SkPath::OppositeDirection(*dir);
     }
     return true;
 }
 
 static inline void add_line_to_segment(const SkPoint& pt, SegmentArray* segments) {
     segments->push_back();
@@ skipping 426 matching lines @@
     drawState->setVertexAttribs<gPathAttribs>(SK_ARRAY_COUNT(gPathAttribs));
 
     static const int kEdgeAttrIndex = 1;
     GrEffectRef* quadEffect = QuadEdgeEffect::Create();
     drawState->addCoverageEffect(quadEffect, kEdgeAttrIndex)->unref();
 
     GrDrawTarget::AutoReleaseGeometry arg(target, vCount, iCount);
     if (!arg.succeeded()) {
         return false;
     }
-    GrAssert(sizeof(QuadVertex) == drawState->getVertexSize());
+    SkASSERT(sizeof(QuadVertex) == drawState->getVertexSize());
     verts = reinterpret_cast<QuadVertex*>(arg.vertices());
     idxs = reinterpret_cast<uint16_t*>(arg.indices());
 
     SkSTArray<kPreallocDrawCnt, Draw, true> draws;
     create_vertices(segments, fanPt, &draws, verts, idxs);
 
     // This is valid because all the computed verts are within 1 pixel of the path control points.
     SkRect devBounds;
     devBounds = path->getBounds();
     viewMatrix.mapRect(&devBounds);
     devBounds.outset(SK_Scalar1, SK_Scalar1);
 
     // Check devBounds
 #if GR_DEBUG
     SkRect tolDevBounds = devBounds;
     tolDevBounds.outset(SK_Scalar1 / 10000, SK_Scalar1 / 10000);
     SkRect actualBounds;
     actualBounds.set(verts[0].fPos, verts[1].fPos);
     for (int i = 2; i < vCount; ++i) {
         actualBounds.growToInclude(verts[i].fPos.fX, verts[i].fPos.fY);
     }
-    GrAssert(tolDevBounds.contains(actualBounds));
+    SkASSERT(tolDevBounds.contains(actualBounds));
 #endif
 
     int vOffset = 0;
     for (int i = 0; i < draws.count(); ++i) {
         const Draw& draw = draws[i];
         target->drawIndexed(kTriangles_GrPrimitiveType,
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }