pathops coincidence and security rewrite

src/pathops/SkPathOpsQuad.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 "SkIntersections.h"
 #include "SkLineParameters.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsCurve.h"
@@ skipping 173 matching lines @@
     double one_t = 1 - t;
     double a = one_t * one_t;
     double b = 2 * one_t * t;
     double c = t * t;
     SkDPoint result = { a * fPts[0].fX + b * fPts[1].fX + c * fPts[2].fX,
             a * fPts[0].fY + b * fPts[1].fY + c * fPts[2].fY };
     return result;
 }
 
 static double interp_quad_coords(const double* src, double t) {
+    if (0 == t) {
+        return src[0];
+    }
+    if (1 == t) {
+        return src[4];
+    }
     double ab = SkDInterp(src[0], src[2], t);
     double bc = SkDInterp(src[2], src[4], t);
     double abc = SkDInterp(ab, bc, t);
     return abc;
 }
 
 bool SkDQuad::monotonicInX() const {
     return between(fPts[0].fX, fPts[1].fX, fPts[2].fX);
 }
 
@@ skipping 17 matching lines @@
 _12 = A/2 + B/2
 12_ = B/2 + C/2
 123 = A/4 + B/2 + C/4
     = D
 
 Group the known values on one side:
 
 B   = D*2 - A/2 - C/2
 */
 
-// OPTIMIZE : special case either or both of t1 = 0, t2 = 1 
+// OPTIMIZE? : special case  t1 = 1 && t2 = 0
 SkDQuad SkDQuad::subDivide(double t1, double t2) const {
+    if (0 == t1 && 1 == t2) {
+        return *this;
+    }
     SkDQuad dst;
     double ax = dst[0].fX = interp_quad_coords(&fPts[0].fX, t1);
     double ay = dst[0].fY = interp_quad_coords(&fPts[0].fY, t1);
     double dx = interp_quad_coords(&fPts[0].fX, (t1 + t2) / 2);
     double dy = interp_quad_coords(&fPts[0].fY, (t1 + t2) / 2);
     double cx = dst[2].fX = interp_quad_coords(&fPts[0].fX, t2);
     double cy = dst[2].fY = interp_quad_coords(&fPts[0].fY, t2);
     /* bx = */ dst[1].fX = 2 * dx - (ax + cx) / 2;
     /* by = */ dst[1].fY = 2 * dy - (ay + cy) / 2;
     return dst;
@@ skipping 13 matching lines @@
     SkDPoint b;
     SkDQuad sub = subDivide(t1, t2);
     SkDLine b0 = {{a, sub[1] + (a - sub[0])}};
     SkDLine b1 = {{c, sub[1] + (c - sub[2])}};
     SkIntersections i;
     i.intersectRay(b0, b1);
     if (i.used() == 1 && i[0][0] >= 0 && i[1][0] >= 0) {
         b = i.pt(0);
     } else {
         SkASSERT(i.used() <= 2);
-        b = SkDPoint::Mid(b0[1], b1[1]);
+        return SkDPoint::Mid(b0[1], b1[1]);
     }
     if (t1 == 0 || t2 == 0) {
         align(0, &b);
     }
     if (t1 == 1 || t2 == 1) {
         align(2, &b);
     }
     if (AlmostBequalUlps(b.fX, a.fX)) {
         b.fX = a.fX;
     } else if (AlmostBequalUlps(b.fX, c.fX)) {
@@ skipping 65 matching lines @@
  * c =             C
  */
 void SkDQuad::SetABC(const double* quad, double* a, double* b, double* c) {
     *a = quad[0];      // a = A
     *b = 2 * quad[2];  // b =     2*B
     *c = quad[4];      // c =             C
     *b -= *c;          // b =     2*B -   C
     *a -= *b;          // a = A - 2*B +   C
     *b -= *c;          // b =     2*B - 2*C
 }