Revert of harden pathops for pathological test

src/pathops/SkPathOpsCommon.cpp

Index: src/pathops/SkPathOpsCommon.cpp
diff --git a/src/pathops/SkPathOpsCommon.cpp b/src/pathops/SkPathOpsCommon.cpp
index 1a5bfc18896d11375766b5971aff9065483f26d5..f7b7273a8d0cf3676a44c414b575e3877c22e66d 100644
--- a/src/pathops/SkPathOpsCommon.cpp
+++ b/src/pathops/SkPathOpsCommon.cpp
@@ -161,7 +161,7 @@
         if (!sortable) {
             continue;
         }
-        // find first angle, initialize winding to computed wind sum
+        // find first angle, initialize winding to computed fWindSum
         const SkOpAngle* angle = segment->spanToAngle(*tIndex, *endIndex);
         const SkOpAngle* firstAngle;
         SkDEBUGCODE(firstAngle = angle);
@@ -208,8 +208,7 @@
                 if (SkOpSegment::UseInnerWinding(maxWinding, winding)) {
                     maxWinding = winding;
                 }
-                // allowed to do nothing
-                (void) segment->markAndChaseWinding(angle, maxWinding, 0, NULL);
+                (void) segment->markAndChaseWinding(angle, maxWinding, 0);
                 break;
             }
         }
@@ -316,12 +315,6 @@
     return;
 }
 
-struct SortableTop {  // error if local in pre-C++11
-    SkOpSegment* fSegment;
-    int fIndex;
-    int fEndIndex;
-};
-
 SkOpSegment* FindSortableTop(const SkTArray<SkOpContour*, true>& contourList,
         SkOpAngle::IncludeType angleIncludeType, bool* firstContour, int* indexPtr,
         int* endIndexPtr, SkPoint* topLeft, bool* unsortable, bool* done, bool* onlyVertical,
@@ -363,8 +356,6 @@
     double tHit;
     SkScalar hitDx = 0;
     SkScalar hitOppDx = 0;
-    // keep track of subsequent returns to detect infinite loops
-    SkTDArray<SortableTop> sortableTops;
     do {
         // if current is vertical, find another candidate which is not
         // if only remaining candidates are vertical, then they can be marked done
@@ -375,35 +366,6 @@
         tryAgain = false;
         contourWinding = rightAngleWinding(contourList, &current, indexPtr, endIndexPtr, &tHit,
                 &hitDx, &tryAgain, onlyVertical, false);
-        if (tryAgain) {
-            bool giveUp = false;
-            int count = sortableTops.count();
-            for (int index = 0; index < count; ++index) {
-                const SortableTop& prev = sortableTops[index];
-                if (giveUp) {
-                    prev.fSegment->markDoneFinal(prev.fIndex);
-                } else if (prev.fSegment == current
-                        && (prev.fIndex == *indexPtr || prev.fEndIndex == *endIndexPtr)) {
-                    // remaining edges are non-vertical and cannot have their winding computed
-                    // mark them as done and return, and hope that assembly can fill the holes
-                    giveUp = true;
-                    index = -1;
-                }
-            }
-            if (giveUp) {
-                *done = true;
-                return NULL;
-            }
-        }
-        SortableTop* sortableTop = sortableTops.append();
-        sortableTop->fSegment = current;
-        sortableTop->fIndex = *indexPtr;
-        sortableTop->fEndIndex = *endIndexPtr;
-#if DEBUG_SORT
-        SkDebugf("%s current=%d index=%d endIndex=%d tHit=%1.9g hitDx=%1.9g try=%d vert=%d\n",
-                __FUNCTION__, current->debugID(), *indexPtr, *endIndexPtr, tHit, hitDx, tryAgain,
-                *onlyVertical);
-#endif
         if (*onlyVertical) {
             return current;
         }
@@ -416,16 +378,10 @@
         oppContourWinding = rightAngleWinding(contourList, &current, indexPtr, endIndexPtr, &tHit,
                 &hitOppDx, &tryAgain, NULL, true);
     } while (tryAgain);
-    bool success = current->initWinding(*indexPtr, *endIndexPtr, tHit, contourWinding, hitDx,
-            oppContourWinding, hitOppDx);
+    current->initWinding(*indexPtr, *endIndexPtr, tHit, contourWinding, hitDx, oppContourWinding,
+            hitOppDx);
     if (current->done()) {
         return NULL;
-    } else if (!success) {  // check if the span has a valid winding
-        int min = SkTMin(*indexPtr, *endIndexPtr);
-        const SkOpSpan& span = current->span(min);
-        if (span.fWindSum == SK_MinS32) {
-            return NULL;
-        }
     }
     return current;
 }
@@ -449,17 +405,14 @@
     }
 }
 
-static bool checkEnds(SkTArray<SkOpContour*, true>* contourList) {
+static void checkEnds(SkTArray<SkOpContour*, true>* contourList) {
     // it's hard to determine if the end of a cubic or conic nearly intersects another curve.
     // instead, look to see if the connecting curve intersected at that same end.
     int contourCount = (*contourList).count();
     for (int cTest = 0; cTest < contourCount; ++cTest) {
         SkOpContour* contour = (*contourList)[cTest];
-        if (!contour->checkEnds()) {
-            return false;
-        }
-    }
-    return true;
+        contour->checkEnds();
+    }
 }
 
 static bool checkMultiples(SkTArray<SkOpContour*, true>* contourList) {
@@ -753,9 +706,7 @@
     SkOpContour::debugShowWindingValues(contourList);
 #endif
     fixOtherTIndex(contourList);
-    if (!checkEnds(contourList)) {  // check if connecting curve intersected at the same end
-        return false;
-    }
+    checkEnds(contourList);  // check if connecting curve intersected at the same end
     bool hasM = checkMultiples(contourList);  // check if intersections agree on t and point values
     SkTDArray<SkOpSegment::AlignedSpan> aligned;
     if (hasM) {