Replace uses of GrAssert by SkASSERT.

src/gpu/GrPathUtils.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 "GrPathUtils.h"
 
 #include "GrPoint.h"
@@ skipping 23 matching lines @@
 }
 
 static const int MAX_POINTS_PER_CURVE = 1 << 10;
 static const SkScalar gMinCurveTol = SkFloatToScalar(0.0001f);
 
 uint32_t GrPathUtils::quadraticPointCount(const GrPoint points[],
                                           SkScalar tol) {
     if (tol < gMinCurveTol) {
         tol = gMinCurveTol;
     }
-    GrAssert(tol > 0);
+    SkASSERT(tol > 0);
 
     SkScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
     if (d <= tol) {
         return 1;
     } else {
         // Each time we subdivide, d should be cut in 4. So we need to
         // subdivide x = log4(d/tol) times. x subdivisions creates 2^(x)
         // points.
         // 2^(log4(x)) = sqrt(x);
         int temp = SkScalarCeil(SkScalarSqrt(SkScalarDiv(d, tol)));
@@ skipping 31 matching lines @@
     uint32_t a = generateQuadraticPoints(p0, q[0], r, tolSqd, points, pointsLeft);
     uint32_t b = generateQuadraticPoints(r, q[1], p2, tolSqd, points, pointsLeft);
     return a + b;
 }
 
 uint32_t GrPathUtils::cubicPointCount(const GrPoint points[],
                                            SkScalar tol) {
     if (tol < gMinCurveTol) {
         tol = gMinCurveTol;
     }
-    GrAssert(tol > 0);
+    SkASSERT(tol > 0);
 
     SkScalar d = GrMax(
         points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
         points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
     d = SkScalarSqrt(d);
     if (d <= tol) {
         return 1;
     } else {
         int temp = SkScalarCeil(SkScalarSqrt(SkScalarDiv(d, tol)));
         int pow2 = GrNextPow2(temp);
@@ skipping 35 matching lines @@
     uint32_t a = generateCubicPoints(p0, q[0], r[0], s, tolSqd, points, pointsLeft);
     uint32_t b = generateCubicPoints(s, r[1], q[2], p3, tolSqd, points, pointsLeft);
     return a + b;
 }
 
 int GrPathUtils::worstCasePointCount(const SkPath& path, int* subpaths,
                                      SkScalar tol) {
     if (tol < gMinCurveTol) {
         tol = gMinCurveTol;
     }
-    GrAssert(tol > 0);
+    SkASSERT(tol > 0);
 
     int pointCount = 0;
     *subpaths = 1;
 
     bool first = true;
 
     SkPath::Iter iter(path, false);
     SkPath::Verb verb;
 
     GrPoint pts[4];
@@ skipping 81 matching lines @@
             // It's a point. It should cover zero area. Just set the matrix such
             // that (u, v) will always be far away from the quad.
             fM[0] = 0; fM[1] = 0; fM[2] = 100.f;
             fM[3] = 0; fM[4] = 0; fM[5] = 100.f;
         }
     } else {
         m.postConcat(UVpts);
 
         // The matrix should not have perspective.
         SkDEBUGCODE(static const SkScalar gTOL = SkFloatToScalar(1.f / 100.f));
-        GrAssert(SkScalarAbs(m.get(SkMatrix::kMPersp0)) < gTOL);
-        GrAssert(SkScalarAbs(m.get(SkMatrix::kMPersp1)) < gTOL);
+        SkASSERT(SkScalarAbs(m.get(SkMatrix::kMPersp0)) < gTOL);
+        SkASSERT(SkScalarAbs(m.get(SkMatrix::kMPersp1)) < gTOL);
 
         // It may not be normalized to have 1.0 in the bottom right
         float m33 = m.get(SkMatrix::kMPersp2);
         if (1.f != m33) {
             m33 = 1.f / m33;
             fM[0] = m33 * m.get(SkMatrix::kMScaleX);
             fM[1] = m33 * m.get(SkMatrix::kMSkewX);
             fM[2] = m33 * m.get(SkMatrix::kMTransX);
             fM[3] = m33 * m.get(SkMatrix::kMSkewY);
             fM[4] = m33 * m.get(SkMatrix::kMScaleY);
@@ skipping 23 matching lines @@
                                     const SkPoint& d,
                                     SkPath::Direction dir,
                                     const SkPoint p) {
     SkVector ap = p - a;
     SkScalar apXab = ap.cross(ab);
     if (SkPath::kCW_Direction == dir) {
         if (apXab > 0) {
             return false;
         }
     } else {
-        GrAssert(SkPath::kCCW_Direction == dir);
+        SkASSERT(SkPath::kCCW_Direction == dir);
         if (apXab < 0) {
             return false;
         }
     }
 
     SkVector dp = p - d;
     SkScalar dpXdc = dp.cross(dc);
     if (SkPath::kCW_Direction == dir) {
         if (dpXdc < 0) {
             return false;
         }
     } else {
-        GrAssert(SkPath::kCCW_Direction == dir);
+        SkASSERT(SkPath::kCCW_Direction == dir);
         if (dpXdc > 0) {
             return false;
         }
     }
     return true;
 }
 
 void convert_noninflect_cubic_to_quads(const SkPoint p[4],
                                        SkScalar toleranceSqd,
                                        bool constrainWithinTangents,
@@ skipping 146 matching lines @@
     // base tolerance is 1 pixel.
     static const SkScalar kTolerance = SK_Scalar1;
     const SkScalar tolSqd = SkScalarSquare(SkScalarMul(tolScale, kTolerance));
 
     for (int i = 0; i < count; ++i) {
         SkPoint* cubic = chopped + 3*i;
         convert_noninflect_cubic_to_quads(cubic, tolSqd, constrainWithinTangents, dir, quads);
     }
 
 }