add conics to path ops

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 14 matching lines @@
             fNext->~SkOpContour();
         }
     }
 
     bool operator<(const SkOpContour& rh) const {
         return fBounds.fTop == rh.fBounds.fTop
                 ? fBounds.fLeft < rh.fBounds.fLeft
                 : fBounds.fTop < rh.fBounds.fTop;
     }
 
+    void addConic(SkPoint pts[3], SkScalar weight, SkChunkAlloc* allocator) {
+        appendSegment(allocator).addConic(pts, weight, this);
+    }
+
     void addCubic(SkPoint pts[4], SkChunkAlloc* allocator) {
         appendSegment(allocator).addCubic(pts, this);
     }
 
     void addCurve(SkPath::Verb verb, const SkPoint pts[4], SkChunkAlloc* allocator);
 
     void addLine(SkPoint pts[2], SkChunkAlloc* allocator) {
         appendSegment(allocator).addLine(pts, this);
     }
 
@@ skipping 46 matching lines @@
 
     void complete() {
         setBounds();
     }
 
     int count() const {
         return fCount;
     }
 
     int debugID() const {
-        return PATH_OPS_DEBUG_RELEASE(fID, -1);
+        return SkDEBUGRELEASE(fID, -1);
     }
 
     int debugIndent() const {
-        return PATH_OPS_DEBUG_RELEASE(fIndent, 0);
+        return SkDEBUGRELEASE(fIndent, 0);
     }
 
 #if DEBUG_ACTIVE_SPANS
     void debugShowActiveSpans() {
         SkOpSegment* segment = &fHead;
         do {
             segment->debugShowActiveSpans();
         } while ((segment = segment->next()));
     }
 #endif
 
     const SkOpAngle* debugAngle(int id) const {
-        return PATH_OPS_DEBUG_RELEASE(globalState()->debugAngle(id), NULL);
+        return SkDEBUGRELEASE(globalState()->debugAngle(id), NULL);
     }
 
     SkOpContour* debugContour(int id) {
-        return PATH_OPS_DEBUG_RELEASE(globalState()->debugContour(id), NULL);
+        return SkDEBUGRELEASE(globalState()->debugContour(id), NULL);
     }
 
     const SkOpPtT* debugPtT(int id) const {
-        return PATH_OPS_DEBUG_RELEASE(globalState()->debugPtT(id), NULL);
+        return SkDEBUGRELEASE(globalState()->debugPtT(id), NULL);
     }
 
     const SkOpSegment* debugSegment(int id) const {
-        return PATH_OPS_DEBUG_RELEASE(globalState()->debugSegment(id), NULL);
+        return SkDEBUGRELEASE(globalState()->debugSegment(id), NULL);
     }
 
     const SkOpSpanBase* debugSpan(int id) const {
-        return PATH_OPS_DEBUG_RELEASE(globalState()->debugSpan(id), NULL);
+        return SkDEBUGRELEASE(globalState()->debugSpan(id), NULL);
     }
 
     SkOpGlobalState* globalState() const {
         return fState; 
     }
 
     void debugValidate() const {
 #if DEBUG_VALIDATE
         const SkOpSegment* segment = &fHead;
         const SkOpSegment* prior = NULL;
@@ skipping 29 matching lines @@
         SkASSERT(fCount > 0);
         return &fHead;
     }
 
     const SkOpSegment* first() const {
         SkASSERT(fCount > 0);
         return &fHead;
     }
 
     void indentDump() {
-        PATH_OPS_DEBUG_CODE(fIndent += 2);
+        SkDEBUGCODE(fIndent += 2);
     }
 
     void init(SkOpGlobalState* globalState, bool operand, bool isXor) {
         fState = globalState;
         fOperand = operand;
         fXor = isXor;
     }
 
     bool isXor() const {
         return fXor;
@@ skipping 34 matching lines @@
 
     bool operand() const {
         return fOperand;
     }
 
     bool oppXor() const {
         return fOppXor;
     }
 
     void outdentDump() {
-        PATH_OPS_DEBUG_CODE(fIndent -= 2);
+        SkDEBUGCODE(fIndent -= 2);
     }
 
     void remove(SkOpContour* contour) {
         if (contour == this) {
             SkASSERT(fCount == 0);
             return;
         }
         SkASSERT(contour->fNext == NULL);
         SkOpContour* prev = this;
         SkOpContour* next;
         while ((next = prev->next()) != contour) {
             SkASSERT(next);
             prev = next;
         }
         SkASSERT(prev);
         prev->setNext(NULL);
     }
 
     void reset() {
         fTail = NULL;
         fNext = NULL;
         fCount = 0;
         fDone = false;
         SkDEBUGCODE(fBounds.set(SK_ScalarMax, SK_ScalarMax, SK_ScalarMin, SK_ScalarMin));
         SkDEBUGCODE(fFirstSorted = -1);
-        PATH_OPS_DEBUG_CODE(fIndent = 0);
+        SkDEBUGCODE(fIndent = 0);
     }
 
     void setBounds() {
         SkASSERT(fCount > 0);
         const SkOpSegment* segment = &fHead;
         fBounds = segment->bounds();
         while ((segment = segment->next())) {
             fBounds.add(segment->bounds());
         }
     }
@@ skipping 66 matching lines @@
     SkOpSegment* fTail;
     SkOpContour* fNext;
     SkTDArray<SkOpSegment*> fSortedSegments;  // set by find top segment
     SkPathOpsBounds fBounds;
     int fCount;
     int fFirstSorted;
     bool fDone;  // set by find top segment
     bool fOperand;  // true for the second argument to a binary operator
     bool fXor;  // set if original path had even-odd fill
     bool fOppXor;  // set if opposite path had even-odd fill
-    PATH_OPS_DEBUG_CODE(int fID);
-    PATH_OPS_DEBUG_CODE(int fIndent);
+    SkDEBUGCODE(int fID);
+    SkDEBUGCODE(int fIndent);
 };
 
 #endif