update pathops to circle sort

tests/PathOpsCubicIntersectionTest.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 "PathOpsCubicIntersectionTestData.h"
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkPathOpsRect.h"
@@ skipping 141 matching lines @@
         {35.597065061143162, 79.872482633158796}, {75.38634169631932, 18.244890038969412}}},
 {{{61.336508189019057, 82.693132843213675}, {44.639380902349664, 54.074825790745592},
         {16.815615499771951, 20.049704667203923}, {41.866884958868326, 56.735503699973002}}},
 
 {{{18.1312339, 31.6473732}, {95.5711034, 63.5350219}, {92.3283165, 62.0158945},
         {18.5656052, 32.1268808}}},
 {{{97.402018, 35.7169972}, {33.1127443, 25.8935163}, {1.13970027, 54.9424981},
         {56.4860195, 60.529264}}},
 };
 
-const size_t testSetCount = SK_ARRAY_COUNT(testSet);
+const int testSetCount = (int) SK_ARRAY_COUNT(testSet);
 
 static const SkDCubic newTestSet[] = {
 {{{275,532}, {277.209137,532}, {279,530.209106}, {279,528}}},
 {{{278,529}, {278,530.65686}, {276.65686,532}, {275,532}}},
 
 #if 0  // FIXME: asserts coincidence, not working yet
 {{{195, 785}, {124.30755615234375, 785}, {67, 841.85986328125}, {67, 912}}},
 {{{67, 913}, {67, 842.30755615234375}, {123.85984039306641, 785}, {194, 785}}},
 #endif
 
@@ skipping 122 matching lines @@
 {{{1, 2}, {5, 6}, {1, 0}, {1, 0}}},
 {{{0, 1}, {0, 1}, {2, 1}, {6, 5}}},
 
 {{{0, 6}, {1, 2}, {1, 0}, {1, 0}}},
 {{{0, 1}, {0, 1}, {6, 0}, {2, 1}}},
 
 {{{0, 2}, {0, 1}, {3, 0}, {1, 0}}},
 {{{0, 3}, {0, 1}, {2, 0}, {1, 0}}},
 };
 
-const size_t newTestSetCount = SK_ARRAY_COUNT(newTestSet);
+const int newTestSetCount = (int) SK_ARRAY_COUNT(newTestSet);
 
 static void oneOff(skiatest::Reporter* reporter, const SkDCubic& cubic1, const SkDCubic& cubic2,
         bool coin) {
     SkASSERT(ValidCubic(cubic1));
     SkASSERT(ValidCubic(cubic2));
 #if ONE_OFF_DEBUG
     SkDebugf("computed quadratics given\n");
     SkDebugf("  {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
         cubic1[0].fX, cubic1[0].fY, cubic1[1].fX, cubic1[1].fY,
         cubic1[2].fX, cubic1[2].fY, cubic1[3].fX, cubic1[3].fY);
@@ skipping 50 matching lines @@
     oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void newOneOff(skiatest::Reporter* reporter, int outer, int inner) {
     const SkDCubic& cubic1 = newTestSet[outer];
     const SkDCubic& cubic2 = newTestSet[inner];
     oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void oneOffTests(skiatest::Reporter* reporter) {
-    for (size_t outer = 0; outer < testSetCount - 1; ++outer) {
-        for (size_t inner = outer + 1; inner < testSetCount; ++inner) {
+    for (int outer = 0; outer < testSetCount - 1; ++outer) {
+        for (int inner = outer + 1; inner < testSetCount; ++inner) {
             oneOff(reporter, outer, inner);
         }
     }
-    for (size_t outer = 0; outer < newTestSetCount - 1; ++outer) {
-        for (size_t inner = outer + 1; inner < newTestSetCount; ++inner) {
+    for (int outer = 0; outer < newTestSetCount - 1; ++outer) {
+        for (int inner = outer + 1; inner < newTestSetCount; ++inner) {
             newOneOff(reporter, outer, inner);
         }
     }
 }
 
 #define DEBUG_CRASH 0
 
 static void CubicIntersection_RandTest(skiatest::Reporter* reporter) {
     srand(0);
     const int tests = 10000000;
@@ skipping 150 matching lines @@
 static const SkDCubic selfSet[] = {
     {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
     {{{3, 6}, {2, 3}, {4, 0}, {3, 2}}},
     {{{0, 2}, {2, 3}, {5, 1}, {3, 2}}},
     {{{0, 2}, {3, 5}, {5, 0}, {4, 2}}},
     {{{3.34, 8.98}, {1.95, 10.27}, {3.76, 7.65}, {4.96, 10.64}}},
     {{{3.13, 2.74}, {1.08, 4.62}, {3.71, 0.94}, {2.01, 3.81}}},
     {{{6.71, 3.14}, {7.99, 2.75}, {8.27, 1.96}, {6.35, 3.57}}},
     {{{12.81, 7.27}, {7.22, 6.98}, {12.49, 8.97}, {11.42, 6.18}}},
 };
-size_t selfSetCount = SK_ARRAY_COUNT(selfSet);
+
+int selfSetCount = (int) SK_ARRAY_COUNT(selfSet);
 
 static void selfOneOff(skiatest::Reporter* reporter, int index) {
     const SkDCubic& cubic = selfSet[index];
 #if ONE_OFF_DEBUG
     int idx2;
     double max[3];
     int ts = cubic.findMaxCurvature(max);
     for (idx2 = 0; idx2 < ts; ++idx2) {
         SkDebugf("%s max[%d]=%1.9g (%1.9g, %1.9g)\n", __FUNCTION__, idx2,
                 max[idx2], cubic.ptAtT(max[idx2]).fX, cubic.ptAtT(max[idx2]).fY);
@@ skipping 17 matching lines @@
     REPORTER_ASSERT(reporter, result == 1);
     REPORTER_ASSERT(reporter, i.used() == 1);
     REPORTER_ASSERT(reporter, !approximately_equal(i[0][0], i[1][0]));
     SkDPoint pt1 = cubic.ptAtT(i[0][0]);
     SkDPoint pt2 = cubic.ptAtT(i[1][0]);
     REPORTER_ASSERT(reporter, pt1.approximatelyEqual(pt2));
     reporter->bumpTestCount();
 }
 
 static void cubicIntersectionSelfTest(skiatest::Reporter* reporter) {
-    size_t firstFail = 0;
-    for (size_t index = firstFail; index < selfSetCount; ++index) {
+    int firstFail = 0;
+    for (int index = firstFail; index < selfSetCount; ++index) {
         selfOneOff(reporter, index);
     }
 }
 
 static const SkDCubic coinSet[] = {
     {{{317, 711}, {322.52285766601562, 711}, {327, 715.4771728515625}, {327, 721}}},
     {{{324.07107543945312, 713.928955078125}, {324.4051513671875, 714.26300048828125},
             {324.71566772460937, 714.62060546875}, {325, 714.9990234375}}},
 
     {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
     {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
 };
 
-size_t coinSetCount = SK_ARRAY_COUNT(coinSet);
+static int coinSetCount = (int) SK_ARRAY_COUNT(coinSet);
 
 static void coinOneOff(skiatest::Reporter* reporter, int index) {
     const SkDCubic& cubic1 = coinSet[index];
     const SkDCubic& cubic2 = coinSet[index + 1];
     oneOff(reporter, cubic1, cubic2, true);
 }
 
 static void cubicIntersectionCoinTest(skiatest::Reporter* reporter) {
-    size_t firstFail = 0;
-    for (size_t index = firstFail; index < coinSetCount; index += 2) {
+    int firstFail = 0;
+    for (int index = firstFail; index < coinSetCount; index += 2) {
         coinOneOff(reporter, index);
     }
 }
 
 DEF_TEST(PathOpsCubicCoinOneOff, reporter) {
     coinOneOff(reporter, 0);
 }
 
 DEF_TEST(PathOpsCubicIntersectionOneOff, reporter) {
     newOneOff(reporter, 0, 1);
 }
 
 DEF_TEST(PathOpsCubicSelfOneOff, reporter) {
     selfOneOff(reporter, 0);
 }
 
 DEF_TEST(PathOpsCubicIntersection, reporter) {
     oneOffTests(reporter);
     cubicIntersectionSelfTest(reporter);
     cubicIntersectionCoinTest(reporter);
     standardTestCases(reporter);
     if (false) CubicIntersection_IntersectionFinder();
     if (false) CubicIntersection_RandTest(reporter);
 }