fix pathops skp-derived bugs; add more failing tests

src/pathops/SkOpSegment.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 "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 2276 matching lines @@
     const SkOpSpan* endSpan = fTs.end() - 1;  // last can't be small
     while (++thisSpan < endSpan) {
         if (!thisSpan->fSmall) {
             continue;
         }
         if (!thisSpan->fWindValue) {
             continue;
         }
         const SkOpSpan& firstSpan = this->firstSpan(*thisSpan);
         const SkOpSpan& lastSpan = this->lastSpan(*thisSpan);
+        const SkOpSpan* nextSpan = &firstSpan + 1;
         ptrdiff_t smallCount = &lastSpan - &firstSpan + 1;
         SkASSERT(1 <= smallCount && smallCount < count());
-        if (smallCount <= 1) {
+        if (smallCount <= 1 && !nextSpan->fSmall) {
             SkASSERT(1 == smallCount);
             checkSmallCoincidence(firstSpan, NULL);
             continue;
         }
         // at this point, check for missing computed intersections
         const SkPoint& testPt = firstSpan.fPt;
         thisSpan = &firstSpan - 1;
         SkOpSegment* other = NULL;
         while (++thisSpan <= &lastSpan) {
             other = thisSpan->fOther;
@@ skipping 750 matching lines @@
         const SkOpSpan& span = fTs[index];
         if (span.fOtherT == t && span.fOther == match) {
             return index;
         }
     }
     return -1;
 }
 
 int SkOpSegment::findT(double t, const SkPoint& pt, const SkOpSegment* match) const {
     int count = this->count();
+    // prefer exact matches over approximate matches
+    for (int index = 0; index < count; ++index) {
+        const SkOpSpan& span = fTs[index];
+        if (span.fT == t && span.fOther == match) {
+            return index;
+        }
+    }
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = fTs[index];
         if (approximately_equal_orderable(span.fT, t) && span.fOther == match) {
             return index;
         }
     }
     // Usually, the pair of ts are an exact match. It's possible that the t values have
     // been adjusted to make multiple intersections align. In this rare case, look for a
     // matching point / match pair instead.
     for (int index = 0; index < count; ++index) {
@@ skipping 899 matching lines @@
 void SkOpSegment::pinT(const SkPoint& pt, double* t) {
     if (pt == fPts[0]) {
         *t = 0;
     }
     int count = SkPathOpsVerbToPoints(fVerb);
     if (pt == fPts[count]) {
         *t = 1;
     }
 }
 
+bool SkOpSegment::reversePoints(const SkPoint& p1, const SkPoint& p2) const {
+    SkASSERT(p1 != p2);
+    int spanCount = count();
+    int p1IndexMin = -1;
+    int p2IndexMax = spanCount;
+    for (int index = 0; index < spanCount; ++index) {
+        const SkOpSpan& span = fTs[index];
+        if (span.fPt == p1) {
+            if (p1IndexMin < 0) {
+                p1IndexMin = index;
+            }
+        } else if (span.fPt == p2) {
+            p2IndexMax = index;
+        }
+    }
+    return p1IndexMin > p2IndexMax;
+}
+
 void SkOpSegment::setCoincidentRange(const SkPoint& startPt, const SkPoint& endPt, 
         SkOpSegment* other) {
     int count = this->count();
     for (int index = 0; index < count; ++index) {
         SkOpSpan &span = fTs[index];
         if ((startPt == span.fPt || endPt == span.fPt) && other == span.fOther) {
             span.fCoincident = true;
         }
     }
 }
@@ skipping 367 matching lines @@
     SkASSERT(span->fWindValue > 0 || span->fOppValue != 0);
     span->fWindValue = 0;
     span->fOppValue = 0;
     if (span->fTiny || span->fSmall) {
         return;
     }
     SkASSERT(!span->fDone);
     span->fDone = true;
     ++fDoneSpans;
 }