fix winding for path ops builder

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 189 matching lines @@
         SkDEBUGCODE(fDebugIndent += 2);
     }
 
     void init(SkOpGlobalState* globalState, bool operand, bool isXor) {
         fState = globalState;
         fOperand = operand;
         fXor = isXor;
         SkDEBUGCODE(fID = globalState->nextContourID());
     }
 
+    int isCcw() const {
+        return fCcw;
+    }
+
     bool isXor() const {
         return fXor;
     }
 
+    void markDone() {
+        SkOpSegment* segment = &fHead;
+        do {
+            segment->markAllDone();
+        } while ((segment = segment->next()));
+    }
+
     void missingCoincidence(SkOpCoincidence* coincidences, SkChunkAlloc* allocator) {
         SkASSERT(fCount > 0);
         SkOpSegment* segment = &fHead;
         do {
             if (fState->angleCoincidence()) {
                 segment->checkAngleCoin(coincidences, allocator);
             } else {
                 segment->missingCoincidence(coincidences, allocator);
             }
         } while ((segment = segment->next()));
@@ skipping 58 matching lines @@
         fTail = NULL;
         fNext = NULL;
         fCount = 0;
         fDone = false;
         fTopsFound = false;
         SkDEBUGCODE(fBounds.set(SK_ScalarMax, SK_ScalarMax, SK_ScalarMin, SK_ScalarMin));
         SkDEBUGCODE(fFirstSorted = -1);
         SkDEBUGCODE(fDebugIndent = 0);
     }
 
+    void resetReverse() {
+        SkOpContour* next = this;
+        do {
+            next->fCcw = -1;
+            next->fReverse = false;
+        } while ((next = next->next()));
+    }
+
+    bool reversed() const {
+        return fReverse;
+    }
+
     void setBounds() {
         SkASSERT(fCount > 0);
         const SkOpSegment* segment = &fHead;
         fBounds = segment->bounds();
         while ((segment = segment->next())) {
             fBounds.add(segment->bounds());
         }
     }
 
+    void setCcw(int ccw) {
+        fCcw = ccw;
+    }
+
     void setGlobalState(SkOpGlobalState* state) {
         fState = state;
     }
 
     void setNext(SkOpContour* contour) {
 //        SkASSERT(!fNext == !!contour);
         fNext = contour;
     }
 
     void setOperand(bool isOp) {
         fOperand = isOp;
     }
 
     void setOppXor(bool isOppXor) {
         fOppXor = isOppXor;
     }
 
+    void setReverse() {
+        fReverse = true;
+    }
+
     void setXor(bool isXor) {
         fXor = isXor;
     }
 
     SkPath::Verb simplifyCubic(SkPoint pts[4]);
 
     void sortAngles() {
         SkASSERT(fCount > 0);
         SkOpSegment* segment = &fHead;
         do {
@@ skipping 12 matching lines @@
         } while ((segment = segment->prev()));
     }
 
     void toPartialForward(SkPathWriter* path) const {
         const SkOpSegment* segment = &fHead;
         do {
             segment->addCurveTo(segment->head(), segment->tail(), path, true);
         } while ((segment = segment->next()));
     }
 
+    void toReversePath(SkPathWriter* path) const;
     void toPath(SkPathWriter* path) const;
     SkOpSegment* undoneSegment(SkOpSpanBase** startPtr, SkOpSpanBase** endPtr);
 
 private:
     SkOpGlobalState* fState;
     SkOpSegment fHead;
     SkOpSegment* fTail;
     SkOpContour* fNext;
     SkPathOpsBounds fBounds;
+    int fCcw;
     int fCount;
     int fFirstSorted;
     bool fDone;  // set by find top segment
     bool fTopsFound;
     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 {
 };
 
 #endif