fix path op conic bugs

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 "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 222 matching lines @@
                 SkOpPtT* ptT = segment->addT(i[0][0], SkOpSegment::kAllowAlias, allocator);
                 ptT->fPt = newPt;
                 endPtT.addOpp(ptT);
             }
     nextSegment:
             ;
         } while ((segment = segment->next()));
     } while ((current = current->next()));
 }
 
-void SkOpSegment::addCurveTo(const SkOpSpanBase* start, const SkOpSpanBase* end,
-        SkPathWriter* path, bool active) const {
+bool SkOpSegment::addCurveTo(const SkOpSpanBase* start, const SkOpSpanBase* end,
+        SkPathWriter* path) const {
+    if (start->starter(end)->alreadyAdded()) {
+        return false;
+    }
     SkOpCurve edge;
     const SkPoint* ePtr;
     SkScalar eWeight;
     if ((start == &fHead && end == &fTail) || (start == &fTail && end == &fHead)) {
         ePtr = fPts;
         eWeight = fWeight;
     } else {
     // OPTIMIZE? if not active, skip remainder and return xyAtT(end)
         subDivide(start, end, &edge);
         ePtr = edge.fPts;
         eWeight = edge.fWeight;
     }
-    if (active) {
-        bool reverse = ePtr == fPts && start != &fHead;
-        if (reverse) {
-            path->deferredMoveLine(ePtr[SkPathOpsVerbToPoints(fVerb)]);
-            switch (fVerb) {
-                case SkPath::kLine_Verb:
-                    path->deferredLine(ePtr[0]);
-                    break;
-                case SkPath::kQuad_Verb:
-                    path->quadTo(ePtr[1], ePtr[0]);
-                    break;
-                case SkPath::kConic_Verb:
-                    path->conicTo(ePtr[1], ePtr[0], eWeight);
-                    break;
-                case SkPath::kCubic_Verb:
-                    path->cubicTo(ePtr[2], ePtr[1], ePtr[0]);
-                    break;
-                default:
-                    SkASSERT(0);
-            }
-       } else {
-            path->deferredMoveLine(ePtr[0]);
-            switch (fVerb) {
-                case SkPath::kLine_Verb:
-                    path->deferredLine(ePtr[1]);
-                    break;
-                case SkPath::kQuad_Verb:
-                    path->quadTo(ePtr[1], ePtr[2]);
-                    break;
-                case SkPath::kConic_Verb:
-                    path->conicTo(ePtr[1], ePtr[2], eWeight);
-                    break;
-                case SkPath::kCubic_Verb:
-                    path->cubicTo(ePtr[1], ePtr[2], ePtr[3]);
-                    break;
-                default:
-                    SkASSERT(0);
-            }
+    bool reverse = ePtr == fPts && start != &fHead;
+    if (reverse) {
+        path->deferredMoveLine(ePtr[SkPathOpsVerbToPoints(fVerb)]);
+        switch (fVerb) {
+            case SkPath::kLine_Verb:
+                path->deferredLine(ePtr[0]);
+                break;
+            case SkPath::kQuad_Verb:
+                path->quadTo(ePtr[1], ePtr[0]);
+                break;
+            case SkPath::kConic_Verb:
+                path->conicTo(ePtr[1], ePtr[0], eWeight);
+                break;
+            case SkPath::kCubic_Verb:
+                path->cubicTo(ePtr[2], ePtr[1], ePtr[0]);
+                break;
+            default:
+                SkASSERT(0);
+        }
+    } else {
+        path->deferredMoveLine(ePtr[0]);
+        switch (fVerb) {
+            case SkPath::kLine_Verb:
+                path->deferredLine(ePtr[1]);
+                break;
+            case SkPath::kQuad_Verb:
+                path->quadTo(ePtr[1], ePtr[2]);
+                break;
+            case SkPath::kConic_Verb:
+                path->conicTo(ePtr[1], ePtr[2], eWeight);
+                break;
+            case SkPath::kCubic_Verb:
+                path->cubicTo(ePtr[1], ePtr[2], ePtr[3]);
+                break;
+            default:
+                SkASSERT(0);
         }
     }
+    return true;
 }
 
 SkOpPtT* SkOpSegment::addMissing(double t, SkOpSegment* opp, SkChunkAlloc* allocator) {
     SkOpSpanBase* existing = nullptr;
     SkOpSpanBase* test = &fHead;
     double testT;
     do {
         if ((testT = test->ptT()->fT) >= t) {
             if (testT == t) {
                 existing = test;
@@ skipping 1462 matching lines @@
     int absOut = SkTAbs(outerWinding);
     int absIn = SkTAbs(innerWinding);
     bool result = absOut == absIn ? outerWinding < 0 : absOut < absIn;
     return result;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     const SkOpSpan* minSpan = angle->start()->starter(angle->end());
     return minSpan->windSum();
 }