harden pathops for pathological test

src/pathops/SkAddIntersections.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 "SkAddIntersections.h"
 #include "SkPathOpsBounds.h"
 
 #if DEBUG_ADD_INTERSECTING_TS
@@ skipping 289 matching lines @@
                                     wn.bottom(), wn.x(), wn.yFlipped());
                             debugShowQuadLineIntersection(pts, wt, wn, ts);
                             break;
                         case SkIntersectionHelper::kLine_Segment: {
                             pts = ts.quadLine(wt.pts(), wn.pts());
                             debugShowQuadLineIntersection(pts, wt, wn, ts);
                             break;
                         }
                         case SkIntersectionHelper::kQuad_Segment: {
                             pts = ts.quadQuad(wt.pts(), wn.pts());
+                            ts.alignQuadPts(wt.pts(), wn.pts());
                             debugShowQuadIntersection(pts, wt, wn, ts);
                             break;
                         }
                         case SkIntersectionHelper::kCubic_Segment: {
                             swap = true;
                             pts = ts.cubicQuad(wn.pts(), wt.pts());
                             debugShowCubicQuadIntersection(pts, wn, wt, ts);
                             break;
                         }
                         default:
@@ skipping 39 matching lines @@
                 next->addCross(test);
                 foundCommonContour = true;
             }
             // in addition to recording T values, record matching segment
             if (pts == 2) {
                 if (wn.segmentType() <= SkIntersectionHelper::kLine_Segment
                         && wt.segmentType() <= SkIntersectionHelper::kLine_Segment) {
                     if (wt.addCoincident(wn, ts, swap)) {
                         continue;
                     }
-                    ts.cleanUpCoincidence();  // prefer (t == 0 or t == 1)
-                    pts = 1;
+                    pts = ts.cleanUpCoincidence();  // prefer (t == 0 or t == 1)
                 } else if (wn.segmentType() >= SkIntersectionHelper::kQuad_Segment
                         && wt.segmentType() >= SkIntersectionHelper::kQuad_Segment
                         && ts.isCoincident(0)) {
                     SkASSERT(ts.coincidentUsed() == 2);
                     if (wt.addCoincident(wn, ts, swap)) {
                         continue;
                     }
-                    ts.cleanUpCoincidence();  // prefer (t == 0 or t == 1)
-                    pts = 1;
+                    pts = ts.cleanUpCoincidence();  // prefer (t == 0 or t == 1)
                 }
             }
             if (pts >= 2) {
                 for (int pt = 0; pt < pts - 1; ++pt) {
                     const SkDPoint& point = ts.pt(pt);
                     const SkDPoint& next = ts.pt(pt + 1);
                     if (wt.isPartial(ts[swap][pt], ts[swap][pt + 1], point, next)
                             && wn.isPartial(ts[!swap][pt], ts[!swap][pt + 1], point, next)) {
                         if (!wt.addPartialCoincident(wn, ts, pt, swap)) {
                             // remove extra point if two map to same float values
-                            ts.cleanUpCoincidence();  // prefer (t == 0 or t == 1)
-                            pts = 1;
+                            pts = ts.cleanUpCoincidence();  // prefer (t == 0 or t == 1)
                         }
                     }
                 }
             }
             for (int pt = 0; pt < pts; ++pt) {
                 SkASSERT(ts[0][pt] >= 0 && ts[0][pt] <= 1);
                 SkASSERT(ts[1][pt] >= 0 && ts[1][pt] <= 1);
                 SkPoint point = ts.pt(pt).asSkPoint();
                 wt.alignTPt(wn, swap, pt, &ts, &point);
                 int testTAt = wt.addT(wn, point, ts[swap][pt]);
@@ skipping 47 matching lines @@
         if (!contour->calcCoincidentWinding()) {
             return false;
         }
     }
     for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
         SkOpContour* contour = (*contourList)[cIndex];
         contour->calcPartialCoincidentWinding();
     }
     return true;
 }