Replace uses of GrAssert by SkASSERT.

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 153 matching lines @@
 
 #define PREALLOC_PTARRAY(N) SkSTArray<(N),SkPoint, true>
 
 // Takes 178th time of logf on Z600 / VC2010
 int get_float_exp(float x) {
     GR_STATIC_ASSERT(sizeof(int) == sizeof(float));
 #if GR_DEBUG
     static bool tested;
     if (!tested) {
         tested = true;
-        GrAssert(get_float_exp(0.25f) == -2);
-        GrAssert(get_float_exp(0.3f) == -2);
-        GrAssert(get_float_exp(0.5f) == -1);
-        GrAssert(get_float_exp(1.f) == 0);
-        GrAssert(get_float_exp(2.f) == 1);
-        GrAssert(get_float_exp(2.5f) == 1);
-        GrAssert(get_float_exp(8.f) == 3);
-        GrAssert(get_float_exp(100.f) == 6);
-        GrAssert(get_float_exp(1000.f) == 9);
-        GrAssert(get_float_exp(1024.f) == 10);
-        GrAssert(get_float_exp(3000000.f) == 21);
+        SkASSERT(get_float_exp(0.25f) == -2);
+        SkASSERT(get_float_exp(0.3f) == -2);
+        SkASSERT(get_float_exp(0.5f) == -1);
+        SkASSERT(get_float_exp(1.f) == 0);
+        SkASSERT(get_float_exp(2.f) == 1);
+        SkASSERT(get_float_exp(2.5f) == 1);
+        SkASSERT(get_float_exp(8.f) == 3);
+        SkASSERT(get_float_exp(100.f) == 6);
+        SkASSERT(get_float_exp(1000.f) == 9);
+        SkASSERT(get_float_exp(1024.f) == 10);
+        SkASSERT(get_float_exp(3000000.f) == 21);
     }
 #endif
     const int* iptr = (const int*)&x;
     return (((*iptr) & 0x7f800000) >> 23) - 127;
 }
 
 // Uses the max curvature function for quads to estimate
 // where to chop the conic. If the max curvature is not
 // found along the curve segment it will return 1 and
 // dst[0] is the original conic. If it returns 2 the dst[0]
@@ skipping 190 matching lines @@
                 int n = SkChopQuadAtMaxCurvature(pathPts, choppedPts);
                 for (int i = 0; i < n; ++i) {
                     SkPoint* quadPts = choppedPts + i * 2;
                     m.mapPoints(devPts, quadPts, 3);
                     bounds.setBounds(devPts, 3);
                     bounds.outset(SK_Scalar1, SK_Scalar1);
                     bounds.roundOut(&ibounds);
 
                     if (SkIRect::Intersects(devClipBounds, ibounds)) {
                         int subdiv = num_quad_subdivs(devPts);
-                        GrAssert(subdiv >= -1);
+                        SkASSERT(subdiv >= -1);
                         if (-1 == subdiv) {
                             SkPoint* pts = lines->push_back_n(4);
                             pts[0] = devPts[0];
                             pts[1] = devPts[1];
                             pts[2] = devPts[1];
                             pts[3] = devPts[2];
                         } else {
                             // when in perspective keep quads in src space
                             SkPoint* qPts = persp ? quadPts : devPts;
                             SkPoint* pts = quads->push_back_n(3);
@@ skipping 35 matching lines @@
                             bounds.setBounds(devPts, 3);
                             qInDevSpace = devPts;
                         } else {
                             bounds.setBounds(&q[i], 3);
                             qInDevSpace = &q[i];
                         }
                         bounds.outset(SK_Scalar1, SK_Scalar1);
                         bounds.roundOut(&ibounds);
                         if (SkIRect::Intersects(devClipBounds, ibounds)) {
                             int subdiv = num_quad_subdivs(qInDevSpace);
-                            GrAssert(subdiv >= -1);
+                            SkASSERT(subdiv >= -1);
                             if (-1 == subdiv) {
                                 SkPoint* pts = lines->push_back_n(4);
                                 // lines should always be in device coords
                                 pts[0] = qInDevSpace[0];
                                 pts[1] = qInDevSpace[1];
                                 pts[2] = qInDevSpace[1];
                                 pts[3] = qInDevSpace[2];
                             } else {
                                 SkPoint* pts = quads->push_back_n(3);
                                 // q is already in src space when there is no
@@ skipping 58 matching lines @@
 
 void set_uv_quad(const SkPoint qpts[3], BezierVertex verts[kVertsPerQuad]) {
     // this should be in the src space, not dev coords, when we have perspective
     GrPathUtils::QuadUVMatrix DevToUV(qpts);
     DevToUV.apply<kVertsPerQuad, sizeof(BezierVertex), sizeof(GrPoint)>(verts);
 }
 
 void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
                 const SkMatrix* toSrc, BezierVertex verts[kVertsPerQuad],
                 SkRect* devBounds) {
-    GrAssert(!toDevice == !toSrc);
+    SkASSERT(!toDevice == !toSrc);
     // original quad is specified by tri a,b,c
     SkPoint a = qpts[0];
     SkPoint b = qpts[1];
     SkPoint c = qpts[2];
 
     if (toDevice) {
         toDevice->mapPoints(&a, 1);
         toDevice->mapPoints(&b, 1);
         toDevice->mapPoints(&c, 1);
     }
@@ skipping 16 matching lines @@
     BezierVertex& c1 = verts[4];
 
     SkVector ab = b;
     ab -= a;
     SkVector ac = c;
     ac -= a;
     SkVector cb = b;
     cb -= c;
 
     // We should have already handled degenerates
-    GrAssert(ab.length() > 0 && cb.length() > 0);
+    SkASSERT(ab.length() > 0 && cb.length() > 0);
 
     ab.normalize();
     SkVector abN;
     abN.setOrthog(ab, SkVector::kLeft_Side);
     if (abN.dot(ac) > 0) {
         abN.negate();
     }
 
     cb.normalize();
     SkVector cbN;
@@ skipping 44 matching lines @@
     k[1] = p[0].fX - p[2].fX;
     k[2] = (p[2].fX - p[0].fX) * p[0].fY - (p[2].fY - p[0].fY) * p[0].fX;
 
     // scale the max absolute value of coeffs to 10
     SkScalar scale = 0.0f;
     for (int i = 0; i < 3; ++i) {
        scale = SkMaxScalar(scale, SkScalarAbs(k[i]));
        scale = SkMaxScalar(scale, SkScalarAbs(l[i]));
        scale = SkMaxScalar(scale, SkScalarAbs(m[i]));
     }
-    GrAssert(scale > 0);
+    SkASSERT(scale > 0);
     scale /= 10.0f;
     k[0] /= scale;
     k[1] /= scale;
     k[2] /= scale;
     l[0] /= scale;
     l[1] /= scale;
     l[2] /= scale;
     m[0] /= scale;
     m[1] /= scale;
     m[2] /= scale;
@@ skipping 31 matching lines @@
     set_conic_coeffs(p, *vert, weight);
     *vert += kVertsPerQuad;
 }
 
 void add_quads(const SkPoint p[3],
                int subdiv,
                const SkMatrix* toDevice,
                const SkMatrix* toSrc,
                BezierVertex** vert,
                SkRect* devBounds) {
-    GrAssert(subdiv >= 0);
+    SkASSERT(subdiv >= 0);
     if (subdiv) {
         SkPoint newP[5];
         SkChopQuadAtHalf(p, newP);
         add_quads(newP + 0, subdiv-1, toDevice, toSrc, vert, devBounds);
         add_quads(newP + 2, subdiv-1, toDevice, toSrc, vert, devBounds);
     } else {
         bloat_quad(p, toDevice, toSrc, *vert, devBounds);
         set_uv_quad(p, *vert);
         *vert += kVertsPerQuad;
     }
@@ skipping 313 matching lines @@
 
     const SkMatrix& viewM = drawState->getViewMatrix();
 
     *devBounds = path.getBounds();
     viewM.mapRect(devBounds);
     devBounds->outset(SK_Scalar1, SK_Scalar1);
 
     int vertCnt = kVertsPerLineSeg * lineCnt;
 
     target->drawState()->setVertexAttribs<gHairlineLineAttribs>(SK_ARRAY_COUNT(gHairlineLineAttribs));
-    GrAssert(sizeof(LineVertex) == target->getDrawState().getVertexSize());
+    SkASSERT(sizeof(LineVertex) == target->getDrawState().getVertexSize());
 
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
 
     LineVertex* verts = reinterpret_cast<LineVertex*>(arg->vertices());
 
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
@@ skipping 28 matching lines @@
     // All the vertices that we compute are within 1 of path control points with the exception of
     // one of the bounding vertices for each quad. The add_quads() function will update the bounds
     // for each quad added.
     *devBounds = path.getBounds();
     viewM.mapRect(devBounds);
     devBounds->outset(SK_Scalar1, SK_Scalar1);
     
     int vertCnt = kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt;
     
     target->drawState()->setVertexAttribs<gHairlineBezierAttribs>(SK_ARRAY_COUNT(gHairlineBezierAttribs));
-    GrAssert(sizeof(BezierVertex) == target->getDrawState().getVertexSize());
+    SkASSERT(sizeof(BezierVertex) == target->getDrawState().getVertexSize());
     
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
     
     BezierVertex* verts = reinterpret_cast<BezierVertex*>(arg->vertices());
     
     const SkMatrix* toDevice = NULL;
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
     
     if (viewM.hasPerspective()) {
         if (viewM.invert(&ivm)) {
             toDevice = &viewM;
             toSrc = &ivm;
         }
     }
     
     int unsubdivQuadCnt = quads.count() / 3;
     for (int i = 0; i < unsubdivQuadCnt; ++i) {
-        GrAssert(qSubdivs[i] >= 0);
+        SkASSERT(qSubdivs[i] >= 0);
         add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &verts, devBounds);
     }
     
     // Start Conics
     for (int i = 0; i < conicCnt; ++i) {
         add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts, devBounds);
     }
     return true;
 }
 
@@ skipping 180 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
     
     target->resetIndexSource();
 
     return true;
 }