fix bugs found by computing flat clips in 800K skps

src/pathops/SkDLineIntersection.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 "SkPathOpsLine.h"
 
 /* Determine the intersection point of two lines. This assumes the lines are not parallel,
@@ skipping 136 matching lines @@
         double ab0x = a[0].fX - b[0].fX;
         double numerA = ab0y * bxLen - byLen * ab0x;
         double numerB = ab0y * axLen - ayLen * ab0x;
         double denom = axByLen - ayBxLen;
         if (between(0, numerA, denom) && between(0, numerB, denom)) {
             fT[0][0] = numerA / denom;
             fT[1][0] = numerB / denom;
             computePoints(a, 1);
         }
     }
+/* Allow tracking that both sets of end points are near each other -- the lines are entirely 
+   coincident -- even when the end points are not exactly the same.
+   Mark this as a 'wild card' for the end points, so that either point is considered totally
+   coincident. Then, avoid folding the lines over each other, but allow either end to mate 
+   to the next set of lines.
+ */
     if (fAllowNear || !unparallel) {
-        for (int iA = 0; iA < 2; ++iA) {
-            if ((t = b.nearPoint(a[iA])) >= 0) {
-                insert(iA, t, a[iA]);
+        double aNearB[2];
+        double bNearA[2];
+        bool aNotB[2] = {false, false};
+        bool bNotA[2] = {false, false};
+        int nearCount = 0;
+        for (int index = 0; index < 2; ++index) {
+            aNearB[index] = t = b.nearPoint(a[index], &aNotB[index]);
+            nearCount += t >= 0;
+            bNearA[index] = t = a.nearPoint(b[index], &bNotA[index]);
+            nearCount += t >= 0;
+        }
+        if (nearCount > 0) {
+            for (int iA = 0; iA < 2; ++iA) {
+                if (!aNotB[iA]) {
+                    continue;
+                }
+                int nearer = aNearB[iA] > 0.5;
+                if (!bNotA[nearer]) {
+                    continue;
+                }
+                SkASSERT(a[iA] != b[nearer]);
+                SkASSERT(iA == (bNearA[nearer] > 0.5));
+                fNearlySame[iA] = true;
+                insertNear(iA, nearer, a[iA], b[nearer]);
+                aNearB[iA] = -1;
+                bNearA[nearer] = -1;
+                nearCount -= 2;
             }
-        }
-        for (int iB = 0; iB < 2; ++iB) {
-            if ((t = a.nearPoint(b[iB])) >= 0) {
-                insert(t, iB, b[iB]);
+            if (nearCount > 0) {
+                for (int iA = 0; iA < 2; ++iA) {
+                    if (aNearB[iA] >= 0) {
+                        insert(iA, aNearB[iA], a[iA]);
+                    }
+                }
+                for (int iB = 0; iB < 2; ++iB) {
+                    if (bNearA[iB] >= 0) {
+                        insert(bNearA[iB], iB, b[iB]);
+                    }
+                }
             }
         }
     }
     cleanUpParallelLines(!unparallel);
     SkASSERT(fUsed <= 2);
     return fUsed;
 }
 
 static int horizontal_coincident(const SkDLine& line, double y) {
     double min = line[0].fY;
@@ skipping 57 matching lines @@
                 for (int index = 0; index < result; ++index) {
                     fT[1][index] = 1 - fT[1][index];
                 }
             }
             fPt[0].fX = xIntercept;
             fPt[0].fY = y;
             fUsed = 1;
         }
     }
     if (fAllowNear || result == 2) {
-        if ((t = line.nearPoint(leftPt)) >= 0) {
+        if ((t = line.nearPoint(leftPt, NULL)) >= 0) {
             insert(t, (double) flipped, leftPt);
         }
         if (left != right) {
             const SkDPoint rightPt = { right, y };
-            if ((t = line.nearPoint(rightPt)) >= 0) {
+            if ((t = line.nearPoint(rightPt, NULL)) >= 0) {
                 insert(t, (double) !flipped, rightPt);
             }
             for (int index = 0; index < 2; ++index) {
                 if ((t = SkDLine::NearPointH(line[index], left, right, y)) >= 0) {
                     insert((double) index, flipped ? 1 - t : t, line[index]);
                 }
             }
         }
     }
     cleanUpParallelLines(result == 2);
@@ skipping 62 matching lines @@
                 for (int index = 0; index < result; ++index) {
                     fT[1][index] = 1 - fT[1][index];
                 }
             }
             fPt[0].fX = x;
             fPt[0].fY = yIntercept;
             fUsed = 1;
         }
     }
     if (fAllowNear || result == 2) {
-        if ((t = line.nearPoint(topPt)) >= 0) {
+        if ((t = line.nearPoint(topPt, NULL)) >= 0) {
             insert(t, (double) flipped, topPt);
         }
         if (top != bottom) {
             SkDPoint bottomPt = { x, bottom };
-            if ((t = line.nearPoint(bottomPt)) >= 0) {
+            if ((t = line.nearPoint(bottomPt, NULL)) >= 0) {
                 insert(t, (double) !flipped, bottomPt);
             }
             for (int index = 0; index < 2; ++index) {
                 if ((t = SkDLine::NearPointV(line[index], top, bottom, x)) >= 0) {
                     insert((double) index, flipped ? 1 - t : t, line[index]);
                 }
             }
         }
     }
     cleanUpParallelLines(result == 2);
     SkASSERT(fUsed <= 2);
     return fUsed;
 }
 
 // from http://www.bryceboe.com/wordpress/wp-content/uploads/2006/10/intersect.py
 // 4 subs, 2 muls, 1 cmp
 static bool ccw(const SkDPoint& A, const SkDPoint& B, const SkDPoint& C) {
     return (C.fY - A.fY) * (B.fX - A.fX) > (B.fY - A.fY) * (C.fX - A.fX);
 }
 
 // 16 subs, 8 muls, 6 cmps
 bool SkIntersections::Test(const SkDLine& a, const SkDLine& b) {
     return ccw(a[0], b[0], b[1]) != ccw(a[1], b[0], b[1])
             && ccw(a[0], a[1], b[0]) != ccw(a[0], a[1], b[1]);
 }