Consolidate SK_CRASH and sk_throw into SK_ABORT

tests/PathOpsCubicLineIntersectionIdeas.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
@@ skipping 176 matching lines @@
         if (largest <= 1) {
 #if 0
             SkDebugf("realRoots=%d (%1.9g, %1.9g, %1.9g) valid=%d (%1.9g, %1.9g, %1.9g)\n",
                 realRoots, allRoots[0], allRoots[1], allRoots[2], valid, validRoots[0],
                 validRoots[1], validRoots[2]);
 #endif
             double smallest = SkTMin(allRoots[0], allRoots[1]);
             if (realRoots == 3) {
                 smallest = SkTMin(smallest, allRoots[2]);
             }
-            SK_ALWAYSBREAK(smallest < 0);
-            SK_ALWAYSBREAK(smallest >= -1);
+            SkASSERT_RELEASE(smallest < 0);
+            SkASSERT_RELEASE(smallest >= -1);
             largeBits = 0;
         } else {
             frexp(largest, &largeBits);
-            SK_ALWAYSBREAK(largeBits >= 0);
-            SK_ALWAYSBREAK(largeBits < 256);
+            SkASSERT_RELEASE(largeBits >= 0);
+            SkASSERT_RELEASE(largeBits < 256);
         }
         double step = 1e-6;
         if (largeBits > 21) {
             step = 1e-1;
         } else if (largeBits > 18) {
             step = 1e-2;
         } else if (largeBits > 15) {
             step = 1e-3;
         } else if (largeBits > 12) {
             step = 1e-4;
         } else if (largeBits > 9) {
             step = 1e-5;
         }
         double diff;
         do {
             double newT = binary_search(cubic, step, pt, t, &iters);
             if (newT >= 0) {
                 diff = fabs(t - newT);
                 break;
             }
             step *= 1.5;
-            SK_ALWAYSBREAK(step < 1);
+            SkASSERT_RELEASE(step < 1);
         } while (true);
         worstStep[largeBits] = SkTMax(worstStep[largeBits], diff);
 #if 0
         {
             cubic.dump();
             SkDebugf("\n");
             SkDLine line = {{{pt.fX - 1, pt.fY}, {pt.fX + 1, pt.fY}}};
             line.dump();
             SkDebugf("\n");
         }
@@ skipping 13 matching lines @@
 
 static double testOneFailure(const CubicLineFailures& failure) {
     const SkDCubic& cubic = failure.c;
     const SkDPoint& pt = failure.p;
     double A, B, C, D;
     SkDCubic::Coefficients(&cubic[0].fY, &A, &B, &C, &D);
     D -= pt.fY;
     double allRoots[3] = {0}, validRoots[3] = {0};
     int realRoots = SkDCubic::RootsReal(A, B, C, D, allRoots);
     int valid = SkDQuad::AddValidTs(allRoots, realRoots, validRoots);
-    SK_ALWAYSBREAK(valid == 1);
-    SK_ALWAYSBREAK(realRoots != 1);
+    SkASSERT_RELEASE(valid == 1);
+    SkASSERT_RELEASE(realRoots != 1);
     double t = validRoots[0];
     SkDPoint calcPt = cubic.ptAtT(t);
-    SK_ALWAYSBREAK(!calcPt.approximatelyEqual(pt));
+    SkASSERT_RELEASE(!calcPt.approximatelyEqual(pt));
     int iters = 0;
     double newT = binary_search(cubic, 0.1, pt, t, &iters);
     return newT;
 }
 
 DEF_TEST(PathOpsCubicLineFailures, reporter) {
     return;  // disable for now
     for (int index = 0; index < cubicLineFailuresCount; ++index) {
         const CubicLineFailures& failure = cubicLineFailures[index];
         double newT = testOneFailure(failure);
-        SK_ALWAYSBREAK(newT >= 0);
+        SkASSERT_RELEASE(newT >= 0);
     }
 }
 
 DEF_TEST(PathOpsCubicLineOneFailure, reporter) {
     return;  // disable for now
     const CubicLineFailures& failure = cubicLineFailures[1];
     double newT = testOneFailure(failure);
-    SK_ALWAYSBREAK(newT >= 0);
+    SkASSERT_RELEASE(newT >= 0);
 }