add conics to path ops

src/pathops/SkOpSpan.cpp

 /*
  * Copyright 2014 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 10 matching lines @@
     return contour()->globalState(); 
 }
 
 void SkOpPtT::init(SkOpSpanBase* span, double t, const SkPoint& pt, bool duplicate) {
     fT = t;
     fPt = pt;
     fSpan = span;
     fNext = this;
     fDuplicatePt = duplicate;
     fDeleted = false;
-    PATH_OPS_DEBUG_CODE(fID = span->globalState()->nextPtTID());
+    SkDEBUGCODE(fID = span->globalState()->nextPtTID());
 }
 
 bool SkOpPtT::onEnd() const {
     const SkOpSpanBase* span = this->span();
     if (span->ptT() != this) {
         return false;
     }
     const SkOpSegment* segment = this->segment();
     return span == segment->head() || span == segment->tail();
 }
@@ skipping 40 matching lines @@
     return span()->segment();
 }
 
 SkOpSegment* SkOpPtT::segment() {
     return span()->segment();
 }
 
 // find the starting or ending span with an existing loop of angles
 // OPTIMIZE? remove the spans pointing to windValue==0 here or earlier?
 // FIXME? assert that only one other span has a valid windValue or oppValue
-void SkOpSpanBase::addSimpleAngle(bool checkFrom, SkChunkAlloc* allocator) {
+bool SkOpSpanBase::addSimpleAngle(bool checkFrom, SkChunkAlloc* allocator) {
     SkOpAngle* angle;
     if (checkFrom) {
-        SkASSERT(this->final());
+        if (!this->final()) {
+            return false;
+        }
         if (this->fromAngle()) {
             SkASSERT(this->fromAngle()->loopCount() == 2);
-            return;
+            return true;
         }
         angle = this->segment()->addEndSpan(allocator);
     } else {
         SkASSERT(this->t() == 0);
         SkOpSpan* span = this->upCast();
         if (span->toAngle()) {
             SkASSERT(span->toAngle()->loopCount() == 2);
             SkASSERT(!span->fromAngle());
             span->setFromAngle(span->toAngle()->next());
-            return;
+            return true;
         }
         angle = this->segment()->addStartSpan(allocator);
     }
     SkOpPtT* ptT = this->ptT();
     SkOpSpanBase* oSpanBase;
     SkOpSpan* oSpan;
     SkOpSegment* other;
     do {
         ptT = ptT->next();
         oSpanBase = ptT->span();
@@ skipping 14 matching lines @@
     SkOpAngle* oAngle;
     if (checkFrom) {
         oAngle = other->addStartSpan(allocator);
         SkASSERT(oSpan && !oSpan->final());
         SkASSERT(oAngle == oSpan->toAngle());
     } else {
         oAngle = other->addEndSpan(allocator);
         SkASSERT(oAngle == oSpanBase->fromAngle());
     }
     angle->insert(oAngle);
+    return true;
 }
 
 void SkOpSpanBase::align() {
     if (this->fAligned) {
         return;
     }
     SkASSERT(!zero_or_one(this->fPtT.fT));
     SkASSERT(this->fPtT.next());
     // if a linked pt/t pair has a t of zero or one, use it as the base for alignment
     SkOpPtT* ptT = &this->fPtT, * stopPtT = ptT;
@@ skipping 114 matching lines @@
 }
 
 void SkOpSpanBase::initBase(SkOpSegment* segment, SkOpSpan* prev, double t, const SkPoint& pt) {
     fSegment = segment;
     fPtT.init(this, t, pt, false);
     fCoinEnd = this;
     fFromAngle = NULL;
     fPrev = prev;
     fAligned = true;
     fChased = false;
-    PATH_OPS_DEBUG_CODE(fCount = 1);
-    PATH_OPS_DEBUG_CODE(fID = globalState()->nextSpanID());
+    SkDEBUGCODE(fCount = 1);
+    SkDEBUGCODE(fID = globalState()->nextSpanID());
 }
 
 // this pair of spans share a common t value or point; merge them and eliminate duplicates
 // this does not compute the best t or pt value; this merely moves all data into a single list
 void SkOpSpanBase::merge(SkOpSpan* span) {
     SkOpPtT* spanPtT = span->ptT();
     SkASSERT(this->t() != spanPtT->fT);
     SkASSERT(!zero_or_one(spanPtT->fT));
     span->detach(this->ptT());
     SkOpPtT* remainder = spanPtT->next();
@@ skipping 57 matching lines @@
 
 void SkOpSpan::setOppSum(int oppSum) {
     SkASSERT(!final());
     if (fOppSum != SK_MinS32 && fOppSum != oppSum) {
         this->globalState()->setWindingFailed();
         return;
     }
     SkASSERT(!DEBUG_LIMIT_WIND_SUM || abs(oppSum) <= DEBUG_LIMIT_WIND_SUM);
     fOppSum = oppSum;
 }