add asserts to point<-->verb helpers

src/core/SkPath.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBuffer.h"
@@ skipping 351 matching lines @@
             case kMove_Verb:
                 SkASSERT(!moveCnt);
                 SkDEBUGCODE(++moveCnt);
                 firstPt = prevPt = pts[0];
                 break;
             case kLine_Verb:
                 nextPt = 1;
                 SkASSERT(moveCnt);
                 break;
             case kQuad_Verb:
+            case kConic_Verb:
                 SkASSERT(moveCnt);
                 nextPt = 2;
                 break;
             case kCubic_Verb:
                 SkASSERT(moveCnt);
                 nextPt = 3;
                 break;
             case kClose_Verb:
                 break;
             default:
@@ skipping 169 matching lines @@
                 // When corners == 3, nextDirection opposes firstDirection.
                 // Otherwise, nextDirection at corner 2 opposes corner 4.
                 int turn = firstDirection ^ (corners - 1);
                 int directionCycle = 3 == corners ? 0 : nextDirection ^ turn;
                 if ((directionCycle ^ turn) != nextDirection) {
                     return false; // direction didn't follow cycle
                 }
                 break;
             }
             case kQuad_Verb:
+            case kConic_Verb:
             case kCubic_Verb:
                 return false; // quadratic, cubic not allowed
             case kMove_Verb:
                 last = *pts++;
                 closedOrMoved = true;
                 break;
+            default:
+                SkASSERT(!"unexpected verb");
+                break;
         }
         *currVerb += 1;
         lastDirection = nextDirection;
     }
     // Success if 4 corners and first point equals last
     bool result = 4 == corners && (first == last || autoClose);
     if (savePts) {
         *ptsPtr = savePts;
     }
     if (result && isClosed) {
@@ skipping 221 matching lines @@
 }
 
 void SkPath::rLineTo(SkScalar x, SkScalar y) {
     SkPoint pt;
     this->getLastPt(&pt);
     this->lineTo(pt.fX + x, pt.fY + y);
 }
 
 void SkPath::quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
     SkDEBUGCODE(this->validate();)
-
+    
     this->injectMoveToIfNeeded();
-
+    
     SkPathRef::Editor ed(&fPathRef);
     SkPoint* pts = ed.growForVerb(kQuad_Verb);
     pts[0].set(x1, y1);
     pts[1].set(x2, y2);
     fSegmentMask |= kQuad_SegmentMask;
-
+    
     GEN_ID_INC;
     DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rQuadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
     SkPoint pt;
     this->getLastPt(&pt);
     this->quadTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2);
 }
 
+void SkPath::conicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
+                     SkScalar w) {
+    // check for <= 0 or NaN with this test
+    if (!(w > 0)) {
+        this->lineTo(x2, y2);
+    } else if (!SkScalarIsFinite(w)) {
+        this->lineTo(x1, y1);
+        this->lineTo(x2, y2);
+    } else if (SK_Scalar1 == w) {
+        this->quadTo(x1, y1, x2, y2);
+    } else {
+        SkDEBUGCODE(this->validate();)
+        
+        this->injectMoveToIfNeeded();
+        
+        SkPathRef::Editor ed(&fPathRef);
+        SkPoint* pts = ed.growForConic(w);
+        pts[0].set(x1, y1);
+        pts[1].set(x2, y2);
+        fSegmentMask |= kConic_SegmentMask;
+        
+        GEN_ID_INC;
+        DIRTY_AFTER_EDIT;
+    }
+}
+
+void SkPath::rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
+                      SkScalar w) {
+    SkPoint pt;
+    this->getLastPt(&pt);
+    this->conicTo(pt.fX + dx1, pt.fY + dy1, pt.fX + dx2, pt.fY + dy2, w);
+}
+
 void SkPath::cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                      SkScalar x3, SkScalar y3) {
     SkDEBUGCODE(this->validate();)
 
     this->injectMoveToIfNeeded();
 
     SkPathRef::Editor ed(&fPathRef);
     SkPoint* pts = ed.growForVerb(kCubic_Verb);
     pts[0].set(x1, y1);
     pts[1].set(x2, y2);
@@ skipping 13 matching lines @@
 }
 
 void SkPath::close() {
     SkDEBUGCODE(this->validate();)
 
     int count = fPathRef->countVerbs();
     if (count > 0) {
         switch (fPathRef->atVerb(count - 1)) {
             case kLine_Verb:
             case kQuad_Verb:
+            case kConic_Verb:
             case kCubic_Verb:
             case kMove_Verb: {
                 SkPathRef::Editor ed(&fPathRef);
                 ed.growForVerb(kClose_Verb);
                 GEN_ID_INC;
                 break;
             }
+            case kClose_Verb:
+                // don't add a close if it's the first verb or a repeat
+                break;
             default:
-                // don't add a close if it's the first verb or a repeat
+                SkASSERT(!"unexpected verb");
                 break;
         }
     }
 
     // signal that we need a moveTo to follow us (unless we're done)
 #if 0
     if (fLastMoveToIndex >= 0) {
         fLastMoveToIndex = ~fLastMoveToIndex;
     }
 #else
@@ skipping 544 matching lines @@
                 this->moveTo(pts[0]);
                 break;
             case kLine_Verb:
                 proc(matrix, &pts[1], &pts[1], 1);
                 this->lineTo(pts[1]);
                 break;
             case kQuad_Verb:
                 proc(matrix, &pts[1], &pts[1], 2);
                 this->quadTo(pts[1], pts[2]);
                 break;
+            case kConic_Verb:
+                proc(matrix, &pts[1], &pts[1], 2);
+                this->conicTo(pts[1], pts[2], iter.conicWeight());
+                break;
             case kCubic_Verb:
                 proc(matrix, &pts[1], &pts[1], 3);
                 this->cubicTo(pts[1], pts[2], pts[3]);
                 break;
             case kClose_Verb:
                 this->close();
                 break;
             default:
                 SkDEBUGFAIL("unknown verb");
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static const uint8_t gPtsInVerb[] = {
-    1,  // kMove
-    1,  // kLine
-    2,  // kQuad
-    3,  // kCubic
-    0,  // kClose
-    0   // kDone
-};
+static int pts_in_verb(unsigned verb) {
+    static const uint8_t gPtsInVerb[] = {
+        1,  // kMove
+        1,  // kLine
+        2,  // kQuad
+        2,  // kConic
+        3,  // kCubic
+        0,  // kClose
+        0   // kDone
+    };
+
+    SkASSERT(verb < SK_ARRAY_COUNT(gPtsInVerb));
+    return gPtsInVerb[verb];
+}
 
 // ignore the initial moveto, and stop when the 1st contour ends
 void SkPath::pathTo(const SkPath& path) {
     int i, vcount = path.fPathRef->countVerbs();
     // exit early if the path is empty, or just has a moveTo.
     if (vcount < 2) {
         return;
     }
 
     SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
 
     fIsOval = false;
 
     const uint8_t* verbs = path.fPathRef->verbs();
     // skip the initial moveTo
     const SkPoint*  pts = path.fPathRef->points() + 1;
+    const SkScalar* conicWeight = path.fPathRef->conicWeights();
 
     SkASSERT(verbs[~0] == kMove_Verb);
     for (i = 1; i < vcount; i++) {
         switch (verbs[~i]) {
             case kLine_Verb:
                 this->lineTo(pts[0].fX, pts[0].fY);
                 break;
             case kQuad_Verb:
                 this->quadTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY);
                 break;
+            case kConic_Verb:
+                this->conicTo(pts[0], pts[1], *conicWeight++);
+                break;
             case kCubic_Verb:
                 this->cubicTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
                 break;
             case kClose_Verb:
                 return;
         }
-        pts += gPtsInVerb[verbs[~i]];
+        pts += pts_in_verb(verbs[~i]);
     }
 }
 
 // ignore the last point of the 1st contour
 void SkPath::reversePathTo(const SkPath& path) {
     int i, vcount = path.fPathRef->countVerbs();
     // exit early if the path is empty, or just has a moveTo.
     if (vcount < 2) {
         return;
     }
 
     SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
 
     fIsOval = false;
 
     const uint8_t*  verbs = path.fPathRef->verbs();
     const SkPoint*  pts = path.fPathRef->points();
+    const SkScalar* conicWeights = path.fPathRef->conicWeights();
 
     SkASSERT(verbs[~0] == kMove_Verb);
     for (i = 1; i < vcount; ++i) {
-        int n = gPtsInVerb[verbs[~i]];
+        unsigned v = verbs[~i];
+        int n = pts_in_verb(v);
         if (n == 0) {
             break;
         }
         pts += n;
+        conicWeights += (SkPath::kConic_Verb == v);
     }
 
     while (--i > 0) {
         switch (verbs[~i]) {
             case kLine_Verb:
                 this->lineTo(pts[-1].fX, pts[-1].fY);
                 break;
             case kQuad_Verb:
                 this->quadTo(pts[-1].fX, pts[-1].fY, pts[-2].fX, pts[-2].fY);
                 break;
+            case kConic_Verb:
+                this->conicTo(pts[-1], pts[-2], *--conicWeights);
+                break;
             case kCubic_Verb:
                 this->cubicTo(pts[-1].fX, pts[-1].fY, pts[-2].fX, pts[-2].fY,
                               pts[-3].fX, pts[-3].fY);
                 break;
             default:
                 SkDEBUGFAIL("bad verb");
                 break;
         }
-        pts -= gPtsInVerb[verbs[~i]];
+        pts -= pts_in_verb(verbs[~i]);
     }
 }
 
 void SkPath::reverseAddPath(const SkPath& src) {
     SkPathRef::Editor ed(&fPathRef, src.fPathRef->countPoints(), src.fPathRef->countVerbs());
 
     const SkPoint* pts = src.fPathRef->pointsEnd();
     // we will iterator through src's verbs backwards
     const uint8_t* verbs = src.fPathRef->verbsMemBegin(); // points at the last verb
     const uint8_t* verbsEnd = src.fPathRef->verbs(); // points just past the first verb
+    const SkScalar* conicWeights = src.fPathRef->conicWeightsEnd();
 
     fIsOval = false;
 
     bool needMove = true;
     bool needClose = false;
     while (verbs < verbsEnd) {
         uint8_t v = *(verbs++);
-        int n = gPtsInVerb[v];
+        int n = pts_in_verb(v);
 
         if (needMove) {
             --pts;
             this->moveTo(pts->fX, pts->fY);
             needMove = false;
         }
         pts -= n;
         switch (v) {
             case kMove_Verb:
                 if (needClose) {
                     this->close();
                     needClose = false;
                 }
                 needMove = true;
                 pts += 1;   // so we see the point in "if (needMove)" above
                 break;
             case kLine_Verb:
                 this->lineTo(pts[0]);
                 break;
             case kQuad_Verb:
                 this->quadTo(pts[1], pts[0]);
                 break;
+            case kConic_Verb:
+                this->conicTo(pts[1], pts[0], *--conicWeights);
+                break;
             case kCubic_Verb:
                 this->cubicTo(pts[2], pts[1], pts[0]);
                 break;
             case kClose_Verb:
                 needClose = true;
                 break;
             default:
                 SkASSERT(!"unexpected verb");
         }
     }
@@ skipping 54 matching lines @@
             switch (verb) {
                 case kMove_Verb:
                     tmp.moveTo(pts[0]);
                     break;
                 case kLine_Verb:
                     tmp.lineTo(pts[1]);
                     break;
                 case kQuad_Verb:
                     subdivide_quad_to(&tmp, pts);
                     break;
+                case kConic_Verb:
+                    SkASSERT(!"TODO: compute new weight");
+                    tmp.conicTo(pts[1], pts[2], iter.conicWeight());
+                    break;
                 case kCubic_Verb:
                     subdivide_cubic_to(&tmp, pts);
                     break;
                 case kClose_Verb:
                     tmp.close();
                     break;
                 default:
                     SkDEBUGFAIL("unknown verb");
                     break;
             }
@@ skipping 77 matching lines @@
                                   // starting processing or we may have just
                                   // closed a contour.
     kAfterMove_SegmentState,      // We have seen a move, but nothing else.
     kAfterPrimitive_SegmentState  // We have seen a primitive but not yet
                                   // closed the path. Also the initial state.
 };
 
 SkPath::Iter::Iter() {
 #ifdef SK_DEBUG
     fPts = NULL;
+    fConicWeights = NULL;
     fMoveTo.fX = fMoveTo.fY = fLastPt.fX = fLastPt.fY = 0;
     fForceClose = fCloseLine = false;
     fSegmentState = kEmptyContour_SegmentState;
 #endif
     // need to init enough to make next() harmlessly return kDone_Verb
     fVerbs = NULL;
     fVerbStop = NULL;
     fNeedClose = false;
 }
 
 SkPath::Iter::Iter(const SkPath& path, bool forceClose) {
     this->setPath(path, forceClose);
 }
 
 void SkPath::Iter::setPath(const SkPath& path, bool forceClose) {
     fPts = path.fPathRef->points();
     fVerbs = path.fPathRef->verbs();
     fVerbStop = path.fPathRef->verbsMemBegin();
+    fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
     fLastPt.fX = fLastPt.fY = 0;
     fMoveTo.fX = fMoveTo.fY = 0;
     fForceClose = SkToU8(forceClose);
     fNeedClose = false;
     fSegmentState = kEmptyContour_SegmentState;
 }
 
 bool SkPath::Iter::isClosedContour() const {
     if (fVerbs == NULL || fVerbs == fVerbStop) {
         return false;
@@ skipping 91 matching lines @@
                         fPts = lastMovePt;
                         return;
                     }
                     return;
                 }
                 // Ignore this line and continue
                 fVerbs--;
                 fPts++;
                 break;
 
+            case kConic_Verb:
             case kQuad_Verb:
                 if (!IsQuadDegenerate(lastPt, fPts[0], fPts[1])) {
                     if (lastMoveVerb) {
                         fVerbs = lastMoveVerb;
                         fPts = lastMovePt;
                         return;
                     }
                     return;
                 }
                 // Ignore this line and continue
                 fVerbs--;
                 fPts += 2;
+                fConicWeights += (kConic_Verb == verb);
                 break;
 
             case kCubic_Verb:
                 if (!IsCubicDegenerate(lastPt, fPts[0], fPts[1], fPts[2])) {
                     if (lastMoveVerb) {
                         fVerbs = lastMoveVerb;
                         fPts = lastMovePt;
                         return;
                     }
                     return;
@@ skipping 49 matching lines @@
             fLastPt = fMoveTo;
             fNeedClose = fForceClose;
             break;
         case kLine_Verb:
             pts[0] = this->cons_moveTo();
             pts[1] = srcPts[0];
             fLastPt = srcPts[0];
             fCloseLine = false;
             srcPts += 1;
             break;
+        case kConic_Verb:
+            fConicWeights += 1;
+            // fall-through
         case kQuad_Verb:
             pts[0] = this->cons_moveTo();
             memcpy(&pts[1], srcPts, 2 * sizeof(SkPoint));
             fLastPt = srcPts[1];
             srcPts += 2;
             break;
         case kCubic_Verb:
             pts[0] = this->cons_moveTo();
             memcpy(&pts[1], srcPts, 3 * sizeof(SkPoint));
             fLastPt = srcPts[2];
@@ skipping 12 matching lines @@
     }
     fPts = srcPts;
     return (Verb)verb;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPath::RawIter::RawIter() {
 #ifdef SK_DEBUG
     fPts = NULL;
+    fConicWeights = NULL;
     fMoveTo.fX = fMoveTo.fY = fLastPt.fX = fLastPt.fY = 0;
 #endif
     // need to init enough to make next() harmlessly return kDone_Verb
     fVerbs = NULL;
     fVerbStop = NULL;
 }
 
 SkPath::RawIter::RawIter(const SkPath& path) {
     this->setPath(path);
 }
 
 void SkPath::RawIter::setPath(const SkPath& path) {
     fPts = path.fPathRef->points();
     fVerbs = path.fPathRef->verbs();
     fVerbStop = path.fPathRef->verbsMemBegin();
+    fConicWeights = path.fPathRef->conicWeights() - 1; // begin one behind
     fMoveTo.fX = fMoveTo.fY = 0;
     fLastPt.fX = fLastPt.fY = 0;
 }
 
 SkPath::Verb SkPath::RawIter::next(SkPoint pts[4]) {
     SkASSERT(NULL != pts);
     if (fVerbs == fVerbStop) {
         return kDone_Verb;
     }
 
     // fVerbs points one beyond next verb so decrement first.
     unsigned verb = *(--fVerbs);
     const SkPoint* srcPts = fPts;
 
     switch (verb) {
         case kMove_Verb:
             pts[0] = *srcPts;
             fMoveTo = srcPts[0];
             fLastPt = fMoveTo;
             srcPts += 1;
             break;
         case kLine_Verb:
             pts[0] = fLastPt;
             pts[1] = srcPts[0];
             fLastPt = srcPts[0];
             srcPts += 1;
             break;
+        case kConic_Verb:
+            fConicWeights += 1;
+            // fall-through
         case kQuad_Verb:
             pts[0] = fLastPt;
             memcpy(&pts[1], srcPts, 2 * sizeof(SkPoint));
             fLastPt = srcPts[1];
             srcPts += 2;
             break;
         case kCubic_Verb:
             pts[0] = fLastPt;
             memcpy(&pts[1], srcPts, 3 * sizeof(SkPoint));
             fLastPt = srcPts[2];
@@ skipping 12 matching lines @@
 
 /*
     Format in compressed buffer: [ptCount, verbCount, pts[], verbs[]]
 */
 
 uint32_t SkPath::writeToMemory(void* storage) const {
     SkDEBUGCODE(this->validate();)
 
     if (NULL == storage) {
         const int byteCount = sizeof(int32_t)
-#if NEW_PICTURE_FORMAT
                       + fPathRef->writeSize()
-#else
-                      + 2 * sizeof(int32_t)
-                      + sizeof(SkPoint) * fPathRef->countPoints()
-                      + sizeof(uint8_t) * fPathRef->countVerbs()
-#endif
                       + sizeof(SkRect);
         return SkAlign4(byteCount);
     }
 
     SkWBuffer   buffer(storage);
-#if !NEW_PICTURE_FORMAT
-    buffer.write32(fPathRef->countPoints());
-    buffer.write32(fPathRef->countVerbs());
-#endif
 
     // Call getBounds() to ensure (as a side-effect) that fBounds
     // and fIsFinite are computed.
     const SkRect& bounds = this->getBounds();
     SkASSERT(!fBoundsIsDirty);
 
     int32_t packed = ((fIsFinite & 1) << kIsFinite_SerializationShift) |
                      ((fIsOval & 1) << kIsOval_SerializationShift) |
                      (fConvexity << kConvexity_SerializationShift) |
                      (fFillType << kFillType_SerializationShift) |
                      (fSegmentMask << kSegmentMask_SerializationShift) |
                      (fDirection << kDirection_SerializationShift);
 
     buffer.write32(packed);
 
     fPathRef->writeToBuffer(&buffer);
 
     buffer.write(&bounds, sizeof(bounds));
 
     buffer.padToAlign4();
     return SkToU32(buffer.pos());
 }
 
 uint32_t SkPath::readFromMemory(const void* storage) {
     SkRBuffer   buffer(storage);
-#if !NEW_PICTURE_FORMAT
-    int32_t pcount = buffer.readS32();
-    int32_t vcount = buffer.readS32();
-#endif
 
     uint32_t packed = buffer.readS32();
     fIsFinite = (packed >> kIsFinite_SerializationShift) & 1;
     fIsOval = (packed >> kIsOval_SerializationShift) & 1;
     fConvexity = (packed >> kConvexity_SerializationShift) & 0xFF;
     fFillType = (packed >> kFillType_SerializationShift) & 0xFF;
-    fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0x7;
+    fSegmentMask = (packed >> kSegmentMask_SerializationShift) & 0xF;
     fDirection = (packed >> kDirection_SerializationShift) & 0x3;
 
-#if NEW_PICTURE_FORMAT
     fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer));
-#else
-    fPathRef.reset(SkPathRef::CreateFromBuffer(vcount, pcount, &buffer));
-#endif
 
     buffer.read(&fBounds, sizeof(fBounds));
     fBoundsIsDirty = false;
 
     buffer.skipToAlign4();
 
     GEN_ID_INC;
 
     SkDEBUGCODE(this->validate();)
     return SkToU32(buffer.pos());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkString.h"
 
 static void append_scalar(SkString* str, SkScalar value) {
     SkString tmp;
     tmp.printf("%g", value);
     if (tmp.contains('.')) {
         tmp.appendUnichar('f');
     }
     str->append(tmp);
 }
 
 static void append_params(SkString* str, const char label[], const SkPoint pts[],
-                          int count) {
+                          int count, SkScalar conicWeight = -1) {
     str->append(label);
     str->append("(");
 
     const SkScalar* values = &pts[0].fX;
     count *= 2;
 
     for (int i = 0; i < count; ++i) {
         append_scalar(str, values[i]);
         if (i < count - 1) {
             str->append(", ");
         }
     }
+    if (conicWeight >= 0) {
+        str->append(", ");
+        append_scalar(str, conicWeight);
+    }
     str->append(");\n");
 }
 
 void SkPath::dump(bool forceClose, const char title[]) const {
     Iter    iter(*this, forceClose);
     SkPoint pts[4];
     Verb    verb;
 
     SkDebugf("path: forceClose=%s %s\n", forceClose ? "true" : "false",
              title ? title : "");
 
     SkString builder;
 
     while ((verb = iter.next(pts, false)) != kDone_Verb) {
         switch (verb) {
             case kMove_Verb:
                 append_params(&builder, "path.moveTo", &pts[0], 1);
                 break;
             case kLine_Verb:
                 append_params(&builder, "path.lineTo", &pts[1], 1);
                 append_params(&builder, "path.lineTo", &pts[1], 1);
                 break;
             case kQuad_Verb:
                 append_params(&builder, "path.quadTo", &pts[1], 2);
                 break;
+            case kConic_Verb:
+                append_params(&builder, "path.conicTo", &pts[1], 2, iter.conicWeight());
+                break;
             case kCubic_Verb:
                 append_params(&builder, "path.cubicTo", &pts[1], 3);
                 break;
             case kClose_Verb:
                 builder.append("path.close();\n");
                 break;
             default:
                 SkDebugf("  path: UNKNOWN VERB %d, aborting dump...\n", verb);
                 verb = kDone_Verb;  // stop the loop
                 break;
@@ skipping 39 matching lines @@
     uint32_t mask = 0;
     const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbs();
     for (int i = 0; i < fPathRef->countVerbs(); i++) {
         switch (verbs[~i]) {
             case kLine_Verb:
                 mask |= kLine_SegmentMask;
                 break;
             case kQuad_Verb:
                 mask |= kQuad_SegmentMask;
                 break;
+            case kConic_Verb:
+                mask |= kConic_SegmentMask;
+                break;
             case kCubic_Verb:
                 mask |= kCubic_SegmentMask;
             case kMove_Verb:  // these verbs aren't included in the segment mask.
             case kClose_Verb:
                 break;
             case kDone_Verb:
                 SkDEBUGFAIL("Done verb shouldn't be recorded.");
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
@@ skipping 120 matching lines @@
             case kMove_Verb:
                 if (++contourCount > 1) {
                     fConvexity = kConcave_Convexity;
                     return kConcave_Convexity;
                 }
                 pts[1] = pts[0];
                 count = 1;
                 break;
             case kLine_Verb: count = 1; break;
             case kQuad_Verb: count = 2; break;
+            case kConic_Verb: count = 2; break;
             case kCubic_Verb: count = 3; break;
             case kClose_Verb:
                 state.close();
                 count = 0;
                 break;
             default:
                 SkDEBUGFAIL("bad verb");
                 fConvexity = kConcave_Convexity;
                 return kConcave_Convexity;
         }
@@ skipping 24 matching lines @@
     // if !done() then these may be called
     int count() const { return fCurrPtCount; }
     const SkPoint* pts() const { return fCurrPt; }
     void next();
 
 private:
     int fCurrPtCount;
     const SkPoint* fCurrPt;
     const uint8_t* fCurrVerb;
     const uint8_t* fStopVerbs;
+    const SkScalar* fCurrConicWeight;
     bool fDone;
     SkDEBUGCODE(int fContourCounter;)
 };
 
 ContourIter::ContourIter(const SkPathRef& pathRef) {
     fStopVerbs = pathRef.verbsMemBegin();
     fDone = false;
     fCurrPt = pathRef.points();
     fCurrVerb = pathRef.verbs();
+    fCurrConicWeight = pathRef.conicWeights();
     fCurrPtCount = 0;
     SkDEBUGCODE(fContourCounter = 0;)
     this->next();
 }
 
 void ContourIter::next() {
     if (fCurrVerb <= fStopVerbs) {
         fDone = true;
     }
     if (fDone) {
         return;
     }
 
     // skip pts of prev contour
     fCurrPt += fCurrPtCount;
 
     SkASSERT(SkPath::kMove_Verb == fCurrVerb[~0]);
     int ptCount = 1;    // moveTo
     const uint8_t* verbs = fCurrVerb;
 
     for (--verbs; verbs > fStopVerbs; --verbs) {
         switch (verbs[~0]) {
             case SkPath::kMove_Verb:
                 goto CONTOUR_END;
             case SkPath::kLine_Verb:
                 ptCount += 1;
                 break;
+            case SkPath::kConic_Verb:
+                fCurrConicWeight += 1;
+                // fall-through
             case SkPath::kQuad_Verb:
                 ptCount += 2;
                 break;
             case SkPath::kCubic_Verb:
                 ptCount += 3;
                 break;
-            default:    // kClose_Verb, just keep going
+            case SkPath::kClose_Verb:
+                break;
+            default:
+                SkASSERT(!"unexpected verb");
                 break;
         }
     }
 CONTOUR_END:
     fCurrPtCount = ptCount;
     fCurrVerb = verbs;
     SkDEBUGCODE(++fContourCounter;)
 }
 
 // returns cross product of (p1 - p0) and (p2 - p0)
@@ skipping 471 matching lines @@
         switch (iter.next(pts, false)) {
             case SkPath::kMove_Verb:
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kLine_Verb:
                 w += winding_line(pts, x, y);
                 break;
             case SkPath::kQuad_Verb:
                 w += winding_quad(pts, x, y);
                 break;
+            case SkPath::kConic_Verb:
+                SkASSERT(0);
+                break;
             case SkPath::kCubic_Verb:
                 w += winding_cubic(pts, x, y);
                 break;
             case SkPath::kDone_Verb:
                 done = true;
                 break;
-        }
+       }
     } while (!done);
 
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }