pathops coincidence and security rewrite

src/pathops/SkPathOpsWinding.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 // given a prospective edge, compute its initial winding by projecting a ray
 // if the ray hits another edge
     // if the edge doesn't have a winding yet, hop up to that edge and start over
@@ skipping 174 matching lines @@
     }
 }
 
 SkOpSpan* SkOpSegment::windingSpanAtT(double tHit) {
     SkOpSpan* span = &fHead;
     SkOpSpanBase* next;
     do {
         next = span->next();
         if (approximately_equal(tHit, next->t())) {
             return nullptr;
-        } 
+        }
         if (tHit < next->t()) {
             return span;
         }
     } while (!next->final() && (span = next->upCast()));
     return nullptr;
 }
 
 static bool hit_compare_x(const SkOpRayHit* a, const SkOpRayHit* b) {
     return a->fPt.fX < b->fPt.fX;
 }
@@ skipping 30 matching lines @@
     SkChunkAlloc allocator(1024);
     int dirOffset;
     double t = get_t_guess(fTopTTry++, &dirOffset);
     SkOpRayHit hitBase;
     SkOpRayDir dir = hitBase.makeTestBase(this, t);
     if (hitBase.fSlope.fX == 0 && hitBase.fSlope.fY == 0) {
         return false;
     }
     SkOpRayHit* hitHead = &hitBase;
     dir = static_cast<SkOpRayDir>(static_cast<int>(dir) + dirOffset);
+    if (hitBase.fSpan && hitBase.fSpan->segment()->verb() > SkPath::kLine_Verb
+            && !pt_yx(hitBase.fSlope.asSkVector(), dir)) {
+        return false;
+    }
     SkOpContour* contour = contourHead;
     do {
         contour->rayCheck(hitBase, dir, &hitHead, &allocator);
     } while ((contour = contour->next()));
     // sort hits
     SkSTArray<1, SkOpRayHit*> sorted;
     SkOpRayHit* hit = hitHead;
     while (hit) {
         sorted.push_back(hit);
         hit = hit->fNext;
     }
     int count = sorted.count();
     SkTQSort(sorted.begin(), sorted.end() - 1, xy_index(dir)
-            ? less_than(dir) ? hit_compare_y : reverse_hit_compare_y 
+            ? less_than(dir) ? hit_compare_y : reverse_hit_compare_y
             : less_than(dir) ? hit_compare_x : reverse_hit_compare_x);
     // verify windings
 #if DEBUG_WINDING
-    SkDebugf("%s dir=%s seg=%d t=%1.9g pt=(%1.9g,%1.9g)\n", __FUNCTION__, 
+    SkDebugf("%s dir=%s seg=%d t=%1.9g pt=(%1.9g,%1.9g)\n", __FUNCTION__,
             gDebugRayDirName[static_cast<int>(dir)], hitBase.fSpan->segment()->debugID(),
             hitBase.fT, hitBase.fPt.fX, hitBase.fPt.fY);
     for (int index = 0; index < count; ++index) {
         hit = sorted[index];
         SkOpSpan* span = hit->fSpan;
         SkOpSegment* hitSegment = span ? span->segment() : nullptr;
         bool operand = span ? hitSegment->operand() : false;
         bool ccw = ccw_dxdy(hit->fSlope, dir);
         SkDebugf("%s [%d] valid=%d operand=%d span=%d ccw=%d ", __FUNCTION__, index,
                 hit->fValid, operand, span ? span->debugID() : -1, ccw);
@@ skipping 97 matching lines @@
         }
         if (span->sortableTop(contourHead)) {
             return span;
         }
     } while (!next->final() && (span = next->upCast()));
     return nullptr;
 }
 
 SkOpSpan* SkOpContour::findSortableTop(SkOpContour* contourHead) {
     SkOpSegment* testSegment = &fHead;
+    bool allDone = true;
     do {
         if (testSegment->done()) {
             continue;
         }
+        allDone = false;
         SkOpSpan* result = testSegment->findSortableTop(contourHead);
         if (result) {
             return result;
         }
     } while ((testSegment = testSegment->next()));
+    if (allDone) {
+      fDone = true;
+    }
     return nullptr;
 }
 
 SkOpSpan* FindSortableTop(SkOpContourHead* contourHead) {
     for (int index = 0; index < SkOpGlobalState::kMaxWindingTries; ++index) {
         SkOpContour* contour = contourHead;
         do {
             if (contour->done()) {
                 continue;
             }
             SkOpSpan* result = contour->findSortableTop(contourHead);
             if (result) {
                 return result;
             }
         } while ((contour = contour->next()));
     }
     return nullptr;
 }