pathops coincidence and security rewrite

src/pathops/SkOpContour.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpContour_DEFINED
 #define SkOpContour_DEFINED
 
 #include "SkOpSegment.h"
 #include "SkTDArray.h"
 #include "SkTSort.h"
 
-class SkChunkAlloc;
 enum class SkOpRayDir;
 struct SkOpRayHit;
 class SkPathWriter;
 
 class SkOpContour {
 public:
     SkOpContour() {
         reset();
     }
 
     ~SkOpContour() {
         if (fNext) {
             fNext->~SkOpContour();
         }
     }
 
     bool operator<(const SkOpContour& rh) const {
         return fBounds.fTop == rh.fBounds.fTop
-                ? fBounds.fLeft < rh.fBounds.fLeft
-                : fBounds.fTop < rh.fBounds.fTop;
+            ? fBounds.fLeft < rh.fBounds.fLeft
+            : fBounds.fTop < rh.fBounds.fTop;
     }
 
-    void addAlignIntersections(SkOpContourHead* contourList, SkChunkAlloc* allocator) {
-        SkASSERT(fCount > 0);
-        SkOpSegment* segment = &fHead;
-        do {
-            segment->addAlignIntersections(contourList, allocator);
-        } while ((segment = segment->next()));
+    void addConic(SkPoint pts[3], SkScalar weight) {
+        appendSegment().addConic(pts, weight, this);
     }
 
-    void addConic(SkPoint pts[3], SkScalar weight, SkChunkAlloc* allocator) {
-        appendSegment(allocator).addConic(pts, weight, this);
+    void addCubic(SkPoint pts[4]) {
+        appendSegment().addCubic(pts, this);
     }
 
-    void addCubic(SkPoint pts[4], SkChunkAlloc* allocator) {
-        appendSegment(allocator).addCubic(pts, this);
+    SkOpSegment* addCurve(SkPath::Verb verb, const SkPoint pts[4]);
+
+    SkOpSegment* addLine(SkPoint pts[2]) {
+        return appendSegment().addLine(pts, this);
     }
 
-    SkOpSegment* addCurve(SkPath::Verb verb, const SkPoint pts[4], SkChunkAlloc* allocator);
-
-    void addLine(SkPoint pts[2], SkChunkAlloc* allocator) {
-        appendSegment(allocator).addLine(pts, this);
+    void addQuad(SkPoint pts[3]) {
+        appendSegment().addQuad(pts, this);
     }
 
-    void addQuad(SkPoint pts[3], SkChunkAlloc* allocator) {
-        appendSegment(allocator).addQuad(pts, this);
-    }
-
-    void align() {
-        SkASSERT(fCount > 0);
-        SkOpSegment* segment = &fHead;
-        do {
-            segment->align();
-        } while ((segment = segment->next()));
-    }
-
-    SkOpSegment& appendSegment(SkChunkAlloc* allocator) {
+    SkOpSegment& appendSegment() {
         SkOpSegment* result = fCount++
-                ? SkOpTAllocator<SkOpSegment>::Allocate(allocator) : &fHead;
+            ? SkOpTAllocator<SkOpSegment>::Allocate(this->globalState()->allocator()) : &fHead;
         result->setPrev(fTail);
         if (fTail) {
             fTail->setNext(result);
         }
         fTail = result;
         return *result;
     }
 
-    SkOpContour* appendContour(SkChunkAlloc* allocator) {
-        SkOpContour* contour = SkOpTAllocator<SkOpContour>::New(allocator);
+    SkOpContour* appendContour() {
+        SkOpContour* contour = SkOpTAllocator<SkOpContour>::New(this->globalState()->allocator());
         contour->setNext(nullptr);
         SkOpContour* prev = this;
         SkOpContour* next;
         while ((next = prev->next())) {
             prev = next;
         }
         prev->setNext(contour);
         return contour;
     }
-    
+
     const SkPathOpsBounds& bounds() const {
         return fBounds;
     }
 
-    void calcAngles(SkChunkAlloc* allocator) {
+    void calcAngles() {
         SkASSERT(fCount > 0);
         SkOpSegment* segment = &fHead;
         do {
-            segment->calcAngles(allocator);
+            segment->calcAngles();
         } while ((segment = segment->next()));
     }
 
     void complete() {
         setBounds();
     }
 
     int count() const {
         return fCount;
     }
@@ skipping 12 matching lines @@
         do {
             segment->debugShowActiveSpans();
         } while ((segment = segment->next()));
     }
 #endif
 
     const SkOpAngle* debugAngle(int id) const {
         return SkDEBUGRELEASE(this->globalState()->debugAngle(id), nullptr);
     }
 
+    const SkOpCoincidence* debugCoincidence() const {
+        return this->globalState()->coincidence();
+    }
+
+#if DEBUG_COINCIDENCE_VERBOSE
     void debugCheckHealth(const char* id, SkPathOpsDebug::GlitchLog* ) const;
+#endif
 
     SkOpContour* debugContour(int id) {
         return SkDEBUGRELEASE(this->globalState()->debugContour(id), nullptr);
     }
 
-    void debugMissingCoincidence(const char* id, SkPathOpsDebug::GlitchLog* log,
-                                 const SkOpCoincidence* coincidence) const;
+#if DEBUG_COINCIDENCE_VERBOSE
+    void debugMissingCoincidence(const char* id, SkPathOpsDebug::GlitchLog* log) const;
+#endif
 
     const SkOpPtT* debugPtT(int id) const {
         return SkDEBUGRELEASE(this->globalState()->debugPtT(id), nullptr);
     }
 
     const SkOpSegment* debugSegment(int id) const {
         return SkDEBUGRELEASE(this->globalState()->debugSegment(id), nullptr);
     }
 
     const SkOpSpanBase* debugSpan(int id) const {
         return SkDEBUGRELEASE(this->globalState()->debugSpan(id), nullptr);
     }
 
     SkOpGlobalState* globalState() const {
-        return fState; 
+        return fState;
     }
 
     void debugValidate() const {
 #if DEBUG_VALIDATE
         const SkOpSegment* segment = &fHead;
         const SkOpSegment* prior = nullptr;
         do {
             segment->debugValidate();
             SkASSERT(segment->prev() == prior);
             prior = segment;
@@ skipping 22 matching lines @@
     void dumpPtsX(const char* prefix) const;
     void dumpSegment(int ) const;
     void dumpSegments(const char* prefix = "seg", SkPathOp op = (SkPathOp) -1) const;
     void dumpSpan(int ) const;
     void dumpSpans() const;
 
     const SkPoint& end() const {
         return fTail->pts()[SkPathOpsVerbToPoints(fTail->verb())];
     }
 
-    bool findCollapsed() {
-        SkASSERT(fCount > 0);
-        SkOpSegment* segment = &fHead;
-        do {
-            segment->findCollapsed();
-        } while ((segment = segment->next()));
-        return true;
-    }
-
     SkOpSpan* findSortableTop(SkOpContour* );
 
     SkOpSegment* first() {
         SkASSERT(fCount > 0);
         return &fHead;
     }
 
     const SkOpSegment* first() const {
         SkASSERT(fCount > 0);
         return &fHead;
@@ skipping 11 matching lines @@
     }
 
     int isCcw() const {
         return fCcw;
     }
 
     bool isXor() const {
         return fXor;
     }
 
-    void markDone() {
+    void markAllDone() {
         SkOpSegment* segment = &fHead;
         do {
             segment->markAllDone();
         } while ((segment = segment->next()));
     }
 
-    bool missingCoincidence(SkOpCoincidence* coincidences, SkChunkAlloc* allocator) {
+    // Please keep this aligned with debugMissingCoincidence()
+    bool missingCoincidence() {
         SkASSERT(fCount > 0);
         SkOpSegment* segment = &fHead;
         bool result = false;
         do {
             if (fState->angleCoincidence()) {
 #if DEBUG_ANGLE
                 segment->debugCheckAngleCoin();
 #endif
-            } else if (segment->missingCoincidence(coincidences, allocator)) {
+            } else if (segment->missingCoincidence()) {
                 result = true;
     // FIXME: trying again loops forever in issue3651_6
     // The continue below is speculative -- once there's an actual case that requires it,
     // add the plumbing necessary to look for another missing coincidence in the same segment
          //       continue; // try again in case another missing coincidence is further along
             }
             segment = segment->next();
         } while (segment);
         return result;
     }
@@ skipping 162 matching lines @@
     bool fXor;  // set if original path had even-odd fill
     bool fOppXor;  // set if opposite path had even-odd fill
     SkDEBUGCODE(int fID);
     SkDEBUGCODE(mutable int fDebugIndent);
 };
 
 class SkOpContourHead : public SkOpContour {
 };
 
 #endif