update pathops to circle sort

tests/PathOpsQuadIntersectionTest.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 "PathOpsQuadIntersectionTestData.h"
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkPathOpsRect.h"
@@ skipping 35 matching lines @@
                                 tt2, xy2.fX, xy2.fY);
                         REPORTER_ASSERT(reporter, 0);
                     }
                 }
             }
         }
     }
 }
 
 static const SkDQuad testSet[] = {
+{{{-708.00779269310044, -154.36998607290101}, {-707.90560262312511, -154.36998607290101}, {-707.8333433370193, -154.44224536635932}}},
+{{{-708.00779269310044, -154.61669472244046}, {-701.04513225634582, -128.85970734043804}, {505.58447265625, -504.9130859375}}},
+
 {{{164, -40}, {231.51681518554687, -40}, {279.25839233398438, 7.7416000366210938}}},
 {{{279.25839233398438, 7.7416000366210938}, {275.2164306640625, 3.6996400356292725}, {271.03286743164062, -5.3290705182007514e-015}}},
 
 {{{2.9999997378517067, 1.9737872594345709}, {2.9999997432230918, 1.9739647181863822}, {1.2414155459263587e-163, 5.2957833941332142e-315}}},
 {{{2.9999047485265304, 1.9739164225694723}, {3.0000947268526112, 1.9738379076623633}, {0.61149411077591886, 0.0028382324376270418}}},
 
     {{{2.9999996843656502, 1.9721416019045801}, {2.9999997725237835, 1.9749798343422071},
             {5.3039068214821359e-315, 8.9546185262775165e-307}}},
     {{{2.9984791443874976, 1.974505741312242}, {2.9999992702127476, 1.9738772171479178},
             {3.0015187977319759, 1.9732495027303418}}},
@@ skipping 233 matching lines @@
 #if 0
     {{{97.9337615966796875,100}, {88,112.94264984130859375}, {88,130}}},
     {{{88,130}, {88,124.80951690673828125}, {88.91983795166015625,120}}},
 #endif
     {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
     {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
     {{{8, 8}, {10, 10}, {8, -10}}},
     {{{8, -10}, {10, 10}, {8, 8}}},
 };
 
-const size_t coincidentTestSetCount = SK_ARRAY_COUNT(coincidentTestSet);
+static const int coincidentTestSetCount = (int) SK_ARRAY_COUNT(coincidentTestSet);
 
 static void coincidentTestOne(skiatest::Reporter* reporter, int test1, int test2) {
     const SkDQuad& quad1 = coincidentTestSet[test1];
     SkASSERT(ValidQuad(quad1));
     const SkDQuad& quad2 = coincidentTestSet[test2];
     SkASSERT(ValidQuad(quad2));
     SkIntersections intersections2;
     intersections2.intersect(quad1, quad2);
     REPORTER_ASSERT(reporter, intersections2.coincidentUsed() == 2);
     REPORTER_ASSERT(reporter, intersections2.used() == 2);
     for (int pt = 0; pt < intersections2.coincidentUsed(); ++pt) {
         double tt1 = intersections2[0][pt];
         double tt2 = intersections2[1][pt];
         SkDPoint pt1 = quad1.ptAtT(tt1);
         SkDPoint pt2 = quad2.ptAtT(tt2);
         REPORTER_ASSERT(reporter, pt1.approximatelyEqual(pt2));
     }
 }
 
 static void coincidentTest(skiatest::Reporter* reporter) {
-    for (size_t testIndex = 0; testIndex < coincidentTestSetCount - 1; testIndex += 2) {
+    for (int testIndex = 0; testIndex < coincidentTestSetCount - 1; testIndex += 2) {
         coincidentTestOne(reporter, testIndex, testIndex + 1);
     }
 }
 
 DEF_TEST(PathOpsQuadIntersectionCoincidenceOneOff, reporter) {
     coincidentTestOne(reporter, 0, 1);
 }
 
 static int floatSign(double x) {
     return x < 0 ? -1 : x > 0 ? 1 : 0;
@@ skipping 158 matching lines @@
     intersectionFinder(0, 1);
 }
 
 DEF_TEST(PathOpsQuadIntersection, reporter) {
     oneOffTests(reporter);
     coincidentTest(reporter);
     standardTestCases(reporter);
     if (false) QuadraticIntersection_IntersectionFinder();
     if (false) QuadraticIntersection_PointFinder();
 }