update pathops to circle sort

src/pathops/SkQuarticRoot.cpp

 // from http://tog.acm.org/resources/GraphicsGems/gems/Roots3And4.c
 /*
  *  Roots3And4.c
  *
  *  Utility functions to find cubic and quartic roots,
  *  coefficients are passed like this:
  *
  *      c[0] + c[1]*x + c[2]*x^2 + c[3]*x^3 + c[4]*x^4 = 0
  *
  *  The functions return the number of non-complex roots and
@@ skipping 53 matching lines @@
         int num = SkDCubic::RootsReal(t4, t3, t2, t1, roots);
         for (int i = 0; i < num; ++i) {
             if (approximately_zero(roots[i])) {
                 return num;
             }
         }
         roots[num++] = 0;
         return num;
     }
     if (oneHint) {
-        SkASSERT(approximately_zero_double(t4 + t3 + t2 + t1 + t0));  // 1 is one root
+        SkASSERT(approximately_zero_double(t4 + t3 + t2 + t1 + t0) ||
+                approximately_zero_when_compared_to(t4 + t3 + t2 + t1 + t0,  // 1 is one root
+                SkTMax(fabs(t4), SkTMax(fabs(t3), SkTMax(fabs(t2), SkTMax(fabs(t1), fabs(t0)))))));
         // note that -C == A + B + D + E
         int num = SkDCubic::RootsReal(t4, t4 + t3, -(t1 + t0), -t0, roots);
         for (int i = 0; i < num; ++i) {
             if (approximately_equal(roots[i], 1)) {
                 return num;
             }
         }
         roots[num++] = 1;
         return num;
     }
     return -1;
 }
 
 int SkQuarticRootsReal(int firstCubicRoot, const double A, const double B, const double C,
         const double D, const double E, double s[4]) {
     double  u, v;
     /* normal form: x^4 + Ax^3 + Bx^2 + Cx + D = 0 */
     const double invA = 1 / A;
     const double a = B * invA;
     const double b = C * invA;
     const double c = D * invA;
     const double d = E * invA;
     /*  substitute x = y - a/4 to eliminate cubic term:
     x^4 + px^2 + qx + r = 0 */
     const double a2 = a * a;
     const double p = -3 * a2 / 8 + b;
     const double q = a2 * a / 8 - a * b / 2 + c;
     const double r = -3 * a2 * a2 / 256 + a2 * b / 16 - a * c / 4 + d;
     int num;
-    if (approximately_zero(r)) {
+    double largest = SkTMax(fabs(p), fabs(q));
+    if (approximately_zero_when_compared_to(r, largest)) {
     /* no absolute term: y(y^3 + py + q) = 0 */
         num = SkDCubic::RootsReal(1, 0, p, q, s);
         s[num++] = 0;
     } else {
         /* solve the resolvent cubic ... */
         double cubicRoots[3];
         int roots = SkDCubic::RootsReal(1, -p / 2, -r, r * p / 2 - q * q / 8, cubicRoots);
         int index;
         /* ... and take one real solution ... */
         double z;
@@ skipping 41 matching lines @@
                 if (j < --num) {
                     s[j] = s[num];
                 }
             } else {
                 ++j;
             }
         }
     }
     return num;
 }