Rewriting path writer

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"
@@ skipping 45 matching lines @@
         SkOpSegment* result = fCount++
             ? SkOpTAllocator<SkOpSegment>::Allocate(this->globalState()->allocator()) : &fHead;
         result->setPrev(fTail);
         if (fTail) {
             fTail->setNext(result);
         }
         fTail = result;
         return *result;
     }
 
-    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() {
         SkASSERT(fCount > 0);
         SkOpSegment* segment = &fHead;
         do {
             segment->calcAngles();
         } while ((segment = segment->next()));
@@ skipping 124 matching lines @@
     }
 
     int isCcw() const {
         return fCcw;
     }
 
     bool isXor() const {
         return fXor;
     }
 
+    void joinSegments() {
+        SkOpSegment* segment = &fHead;
+        SkOpSegment* next;
+        do {
+            next = segment->next();
+            segment->joinEnds(next ? next : &fHead);
+        } while ((segment = next));
+    }
+
     void markAllDone() {
         SkOpSegment* segment = &fHead;
         do {
             segment->markAllDone();
         } while ((segment = segment->next()));
     }
 
     // Please keep this aligned with debugMissingCoincidence()
     bool missingCoincidence() {
         SkASSERT(fCount > 0);
@@ skipping 50 matching lines @@
     bool oppXor() const {
         return fOppXor;
     }
 
     void outdentDump() const {
         SkDEBUGCODE(fDebugIndent -= 2);
     }
 
     void rayCheck(const SkOpRayHit& base, SkOpRayDir dir, SkOpRayHit** hits, SkChunkAlloc* );
 
-    void remove(SkOpContour* contour) {
-        if (contour == this) {
-            SkASSERT(fCount == 0);
-            return;
-        }
-        SkASSERT(contour->fNext == nullptr);
-        SkOpContour* prev = this;
-        SkOpContour* next;
-        while ((next = prev->next()) != contour) {
-            SkASSERT(next);
-            prev = next;
-        }
-        SkASSERT(prev);
-        prev->setNext(nullptr);
-    }
-
     void reset() {
         fTail = nullptr;
         fNext = nullptr;
         fCount = 0;
         fDone = false;
         SkDEBUGCODE(fBounds.set(SK_ScalarMax, SK_ScalarMax, SK_ScalarMin, SK_ScalarMin));
         SkDEBUGCODE(fFirstSorted = -1);
         SkDEBUGCODE(fDebugIndent = 0);
     }
 
@@ skipping 91 matching lines @@
     bool fDone;  // set by find top segment
     bool fOperand;  // true for the second argument to a binary operator
     bool fReverse;  // true if contour should be reverse written to path (used only by fix winding)
     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 {
+public:
+    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;
+    }
+
+    void joinAllSegments() {
+        SkOpContour* next = this;
+        do {
+            next->joinSegments();
+        } while ((next = next->next()));
+    }
+
+    void remove(SkOpContour* contour) {
+        if (contour == this) {
+            SkASSERT(this->count() == 0);
+            return;
+        }
+        SkASSERT(contour->next() == nullptr);
+        SkOpContour* prev = this;
+        SkOpContour* next;
+        while ((next = prev->next()) != contour) {
+            SkASSERT(next);
+            prev = next;
+        }
+        SkASSERT(prev);
+        prev->setNext(nullptr);
+    }
+
 };
 
 #endif