Revert of added stroking support to GrAALinearizingConvexPathRenderer

src/gpu/GrAAConvexTessellator.cpp

Index: src/gpu/GrAAConvexTessellator.cpp
diff --git a/src/gpu/GrAAConvexTessellator.cpp b/src/gpu/GrAAConvexTessellator.cpp
index 85ce7ba9ed6bc17681cbc791d7134210861e0539..56a408d644d468c56fffe98e1b65e05018354385 100644
--- a/src/gpu/GrAAConvexTessellator.cpp
+++ b/src/gpu/GrAAConvexTessellator.cpp
@@ -13,6 +13,7 @@
 #include "GrPathUtils.h"
 
 // Next steps:
+//  use in AAConvexPathRenderer
 //  add an interactive sample app slide
 //  add debug check that all points are suitably far apart
 //  test more degenerate cases
@@ -21,17 +22,10 @@
 static const SkScalar kClose = (SK_Scalar1 / 16);
 static const SkScalar kCloseSqd = SkScalarMul(kClose, kClose);
 
-// tesselation tolerance values, in device space pixels
-static const SkScalar kQuadTolerance = 0.2f;
-static const SkScalar kCubicTolerance = 0.2f;
-static const SkScalar kConicTolerance = 0.5f;
-
-// dot product below which we use a round cap between curve segments
-static const SkScalar kRoundCapThreshold = 0.8f;
-
 static SkScalar intersect(const SkPoint& p0, const SkPoint& n0,
                           const SkPoint& p1, const SkPoint& n1) {
     const SkPoint v = p1 - p0;
+
     SkScalar perpDot = n0.fX * n1.fY - n0.fY * n1.fX;
     return (v.fX * n1.fY - v.fY * n1.fX) / perpDot;
 }
@@ -58,14 +52,13 @@
 
 int GrAAConvexTessellator::addPt(const SkPoint& pt,
                                  SkScalar depth,
-                                 SkScalar coverage,
                                  bool movable,
                                  bool isCurve) {
     this->validate();
 
     int index = fPts.count();
     *fPts.push() = pt;
-    *fCoverages.push() = coverage;
+    *fDepths.push() = depth;
     *fMovable.push() = movable;
     *fIsCurve.push() = isCurve;
 
@@ -77,7 +70,7 @@
     this->validate();
 
     fPts.pop();
-    fCoverages.pop();
+    fDepths.pop();
     fMovable.pop();
 
     this->validate();
@@ -87,7 +80,7 @@
     this->validate();
 
     fPts.removeShuffle(0);
-    fCoverages.removeShuffle(0);
+    fDepths.removeShuffle(0);
     fMovable.removeShuffle(0);
 
     this->validate();
@@ -95,13 +88,12 @@
 
 void GrAAConvexTessellator::updatePt(int index,
                                      const SkPoint& pt,
-                                     SkScalar depth,
-                                     SkScalar coverage) {
+                                     SkScalar depth) {
     this->validate();
     SkASSERT(fMovable[index]);
 
     fPts[index] = pt;
-    fCoverages[index] = coverage;
+    fDepths[index] = depth;
 }
 
 void GrAAConvexTessellator::addTri(int i0, int i1, int i2) {
@@ -116,7 +108,7 @@
 
 void GrAAConvexTessellator::rewind() {
     fPts.rewind();
-    fCoverages.rewind();
+    fDepths.rewind();
     fMovable.rewind();
     fIndices.rewind();
     fNorms.rewind();
@@ -151,44 +143,6 @@
     }
 }
 
-// Create as many rings as we need to (up to a predefined limit) to reach the specified target
-// depth. If we are in fill mode, the final ring will automatically be fanned.
-bool GrAAConvexTessellator::createInsetRings(Ring& previousRing, SkScalar initialDepth,
-                                             SkScalar initialCoverage, SkScalar targetDepth, 
-                                             SkScalar targetCoverage, Ring** finalRing) {
-    static const int kMaxNumRings = 8;
-
-    if (previousRing.numPts() < 3) {
-        return false;
-    }
-    Ring* currentRing = &previousRing;
-    int i;
-    for (i = 0; i < kMaxNumRings; ++i) {
-        Ring* nextRing = this->getNextRing(currentRing);
-        SkASSERT(nextRing != currentRing);
-
-        bool done = this->createInsetRing(*currentRing, nextRing, initialDepth, initialCoverage, 
-                                          targetDepth, targetCoverage, i == 0);
-        currentRing = nextRing;
-        if (done) {
-            break;
-        }
-        currentRing->init(*this);
-    }
-
-    if (kMaxNumRings == i) {
-        // Bail if we've exceeded the amount of time we want to throw at this.
-        this->terminate(*currentRing);
-        return false;
-    }
-    bool done = currentRing->numPts() >= 3;
-    if (done) {
-        currentRing->init(*this);
-    }
-    *finalRing = currentRing;
-    return done;
-}
-
 // The general idea here is to, conceptually, start with the original polygon and slide
 // the vertices along the bisectors until the first intersection. At that
 // point two of the edges collapse and the process repeats on the new polygon.
@@ -196,40 +150,46 @@
 // controls the iteration. The CandidateVerts holds the formative points for the
 // next ring.
 bool GrAAConvexTessellator::tessellate(const SkMatrix& m, const SkPath& path) {
+    static const int kMaxNumRings = 8;
+
+    SkDEBUGCODE(fShouldCheckDepths = true;)
+
     if (!this->extractFromPath(m, path)) {
         return false;
     }
 
-    SkScalar coverage = 1.0f;
-    if (fStrokeWidth >= 0.0f) {
-        Ring outerStrokeRing;
-        this->createOuterRing(fInitialRing, fStrokeWidth / 2 - kAntialiasingRadius, coverage,
-                              &outerStrokeRing);
-        outerStrokeRing.init(*this);
-        Ring outerAARing;
-        this->createOuterRing(outerStrokeRing, kAntialiasingRadius * 2, 0.0f, &outerAARing);
-    } else {
-        Ring outerAARing;
-        this->createOuterRing(fInitialRing, kAntialiasingRadius, 0.0f, &outerAARing);
-    }
+    this->createOuterRing();
 
     // the bisectors are only needed for the computation of the outer ring
     fBisectors.rewind();
-    if (fStrokeWidth >= 0.0f && fInitialRing.numPts() > 2) {
-        Ring* insetStrokeRing;
-        SkScalar strokeDepth = fStrokeWidth / 2 - kAntialiasingRadius;
-        if (this->createInsetRings(fInitialRing, 0.0f, coverage, strokeDepth, coverage, 
-                             &insetStrokeRing)) {
-            Ring* insetAARing;
-            this->createInsetRings(*insetStrokeRing, strokeDepth, coverage, strokeDepth + 
-                             kAntialiasingRadius * 2, 0.0f, &insetAARing);
-        }
-    } else {
-        Ring* insetAARing;
-        this->createInsetRings(fInitialRing, 0.0f, 0.5f, kAntialiasingRadius, 1.0f, &insetAARing);
-    }
-
-    SkDEBUGCODE(this->validate();)
+
+    Ring* lastRing = &fInitialRing;
+    int i;
+    for (i = 0; i < kMaxNumRings; ++i) {
+        Ring* nextRing = this->getNextRing(lastRing);
+
+        if (this->createInsetRing(*lastRing, nextRing)) {
+            break;
+        }
+
+        nextRing->init(*this);
+        lastRing = nextRing;
+    }
+
+    if (kMaxNumRings == i) {
+        // If we've exceeded the amount of time we want to throw at this, set
+        // the depth of all points in the final ring to 'fTargetDepth' and
+        // create a fan.
+        this->terminate(*lastRing);
+        SkDEBUGCODE(fShouldCheckDepths = false;)
+    }
+
+#ifdef SK_DEBUG
+    this->validate();
+    if (fShouldCheckDepths) {
+        SkDEBUGCODE(this->checkAllDepths();)
+    }
+#endif
     return true;
 }
 
@@ -238,6 +198,7 @@
 
     SkPoint v = p - fPts[edgeIdx];
     SkScalar depth = -fNorms[edgeIdx].dot(v);
+    SkASSERT(depth >= 0.0f);
     return depth;
 }
 
@@ -252,13 +213,13 @@
 
     // First find the point where the edge and the bisector intersect
     SkPoint newP;
-
     SkScalar t = perp_intersect(fPts[startIdx], bisector, fPts[edgeIdx], norm);
     if (SkScalarNearlyEqual(t, 0.0f)) {
         // the start point was one of the original ring points
-        SkASSERT(startIdx < fPts.count());
+        SkASSERT(startIdx < fNorms.count());
         newP = fPts[startIdx];
-    } else if (t < 0.0f) {
+    } else if (t > 0.0f) {
+        SkASSERT(t < 0.0f);
         newP = bisector;
         newP.scale(t);
         newP += fPts[startIdx];
@@ -267,11 +228,12 @@
     }
 
     // Then offset along the bisector from that point the correct distance
-    SkScalar dot = bisector.dot(norm);
-    t = -desiredDepth / dot;
+    t = -desiredDepth / bisector.dot(norm);
+    SkASSERT(t > 0.0f);
     *result = bisector;
     result->scale(t);
     *result += newP;
+
 
     return true;
 }
@@ -289,6 +251,9 @@
     fIndices.setReserve(18*path.countPoints() + 6);
 
     fNorms.setReserve(path.countPoints());
+
+    SkDEBUGCODE(fMinCross = SK_ScalarMax;)
+    SkDEBUGCODE(fMaxCross = -SK_ScalarMax;)
 
     // TODO: is there a faster way to extract the points from the path? Perhaps
     // get all the points via a new entry point, transform them all in bulk
@@ -317,7 +282,7 @@
         }
     }
 
-    if (this->numPts() < 2) {
+    if (this->numPts() < 3) {
         return false;
     }
 
@@ -328,20 +293,23 @@
     }
 
     SkASSERT(fPts.count() == fNorms.count()+1);
-    if (this->numPts() >= 3) {
-        if (abs_dist_from_line(fPts.top(), fNorms.top(), fPts[0]) < kClose) {
-            // The last point is on the line from the second to last to the first point.
-            this->popLastPt();
-            fNorms.pop();
-        }
-
-        *fNorms.push() = fPts[0] - fPts.top();
-        SkDEBUGCODE(SkScalar len =) SkPoint::Normalize(&fNorms.top());
-        SkASSERT(len > 0.0f);
-        SkASSERT(fPts.count() == fNorms.count());
-    }
-
-    if (this->numPts() >= 3 && abs_dist_from_line(fPts[0], fNorms.top(), fPts[1]) < kClose) {
+    if (this->numPts() >= 3 &&
+        abs_dist_from_line(fPts.top(), fNorms.top(), fPts[0]) < kClose) {
+        // The last point is on the line from the second to last to the first point.
+        this->popLastPt();
+        fNorms.pop();
+    }
+
+    if (this->numPts() < 3) {
+        return false;
+    }
+
+    *fNorms.push() = fPts[0] - fPts.top();
+    SkDEBUGCODE(SkScalar len =) SkPoint::Normalize(&fNorms.top());
+    SkASSERT(len > 0.0f);
+    SkASSERT(fPts.count() == fNorms.count());
+
+    if (abs_dist_from_line(fPts[0], fNorms.top(), fPts[1]) < kClose) {
         // The first point is on the line from the last to the second.
         this->popFirstPtShuffle();
         fNorms.removeShuffle(0);
@@ -351,44 +319,28 @@
         SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[0].length()));
     }
 
-    if (this->numPts() >= 3) {
-        // Check the cross product of the final trio
-        SkScalar cross = SkPoint::CrossProduct(fNorms[0], fNorms.top());
-        if (cross > 0.0f) {
-            fSide = SkPoint::kRight_Side;
-        } else {
-            fSide = SkPoint::kLeft_Side;
-        }
-
-        // Make all the normals face outwards rather than along the edge
-        for (int cur = 0; cur < fNorms.count(); ++cur) {
-            fNorms[cur].setOrthog(fNorms[cur], fSide);
-            SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
-        }
-
-        this->computeBisectors();
-    } else if (this->numPts() == 2) {
-        // We've got two points, so we're degenerate. 
-        if (fStrokeWidth < 0.0f) {
-            // it's a fill, so we don't need to worry about degenerate paths
-            return false;
-        }
-        // For stroking, we still need to process the degenerate path, so fix it up
+    if (this->numPts() < 3) {
+        return false;
+    }
+
+    // Check the cross product of the final trio
+    SkScalar cross = SkPoint::CrossProduct(fNorms[0], fNorms.top());
+    SkDEBUGCODE(fMaxCross = SkTMax(fMaxCross, cross));
+    SkDEBUGCODE(fMinCross = SkTMin(fMinCross, cross));
+    SkASSERT((fMaxCross >= 0.0f) == (fMinCross >= 0.0f));
+    if (cross > 0.0f) {
+        fSide = SkPoint::kRight_Side;
+    } else {
         fSide = SkPoint::kLeft_Side;
-
-        // Make all the normals face outwards rather than along the edge
-        for (int cur = 0; cur < fNorms.count(); ++cur) {
-            fNorms[cur].setOrthog(fNorms[cur], fSide);
-            SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
-        }
-
-        fNorms.push(SkPoint::Make(-fNorms[0].fX, -fNorms[0].fY));
-        // we won't actually use the bisectors, so just push zeroes
-        fBisectors.push(SkPoint::Make(0.0, 0.0));
-        fBisectors.push(SkPoint::Make(0.0, 0.0));
-    } else {
-        return false;
-    }
+    }
+
+    // Make all the normals face outwards rather than along the edge
+    for (int cur = 0; cur < fNorms.count(); ++cur) {
+        fNorms[cur].setOrthog(fNorms[cur], fSide);
+        SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
+    }
+
+    this->computeBisectors();
 
     fCandidateVerts.setReserve(this->numPts());
     fInitialRing.setReserve(this->numPts());
@@ -418,172 +370,138 @@
 
 void GrAAConvexTessellator::fanRing(const Ring& ring) {
     // fan out from point 0
-    int startIdx = ring.index(0);
-    for (int cur = ring.numPts() - 2; cur >= 0; --cur) {
-        this->addTri(startIdx, ring.index(cur), ring.index(cur + 1));
-    }
-}
-
-void GrAAConvexTessellator::createOuterRing(const Ring& previousRing, SkScalar outset, 
-                                            SkScalar coverage, Ring* nextRing) {
-    const int numPts = previousRing.numPts();
-    if (numPts == 0) {
-        return;
-    }
+    for (int cur = 1; cur < ring.numPts()-1; ++cur) {
+        this->addTri(ring.index(0), ring.index(cur), ring.index(cur+1));
+    }
+}
+
+void GrAAConvexTessellator::createOuterRing() {
+    // For now, we're only generating one outer ring (at the start). This
+    // could be relaxed for stroking use cases.
+    SkASSERT(0 == fIndices.count());  
+    SkASSERT(fPts.count() == fNorms.count());
+
+    const int numPts = fPts.count();
 
     int prev = numPts - 1;
-    int lastPerpIdx = -1, firstPerpIdx = -1;
-
-    const SkScalar outsetSq = SkScalarMul(outset, outset);
-    SkScalar miterLimitSq = SkScalarMul(outset, fMiterLimit);
-    miterLimitSq = SkScalarMul(miterLimitSq, miterLimitSq);
+    int lastPerpIdx = -1, firstPerpIdx = -1, newIdx0, newIdx1, newIdx2;
     for (int cur = 0; cur < numPts; ++cur) {
-        int originalIdx = previousRing.index(cur);
-        // For each vertex of the original polygon we add at least two points to the 
-        // outset polygon - one extending perpendicular to each impinging edge. Connecting these
-        // two points yields a bevel join. We need one additional point for a mitered join, and 
-        // a round join requires one or more points depending upon curvature.
-
-        // The perpendicular point for the last edge
-        SkPoint normal1 = previousRing.norm(prev);
-        SkPoint perp1 = normal1;
-        perp1.scale(outset);
-        perp1 += this->point(originalIdx);
-
-        // The perpendicular point for the next edge.
-        SkPoint normal2 = previousRing.norm(cur);
-        SkPoint perp2 = normal2;
-        perp2.scale(outset);
-        perp2 += fPts[originalIdx];
-
-        bool isCurve = fIsCurve[originalIdx];
-
-        // We know it isn't a duplicate of the prior point (since it and this
-        // one are just perpendicular offsets from the non-merged polygon points)
-        int perp1Idx = this->addPt(perp1, -outset, coverage, false, isCurve);
-        nextRing->addIdx(perp1Idx, originalIdx);
-
-        int perp2Idx;
-        // For very shallow angles all the corner points could fuse.
-        if (duplicate_pt(perp2, this->point(perp1Idx))) {
-            perp2Idx = perp1Idx;
-        } else {
-            perp2Idx = this->addPt(perp2, -outset, coverage, false, isCurve);
-        }
-
-        if (perp2Idx != perp1Idx) {
-            if (isCurve) {
-                // bevel or round depending upon curvature
-                SkScalar dotProd = normal1.dot(normal2);
-                if (dotProd < kRoundCapThreshold) {
-                    // Currently we "round" by creating a single extra point, which produces
-                    // good results for common cases. For thick strokes with high curvature, we will
-                    // need to add more points; for the time being we simply fall back to software
-                    // rendering for thick strokes.
-                    SkPoint miter = previousRing.bisector(cur);
-                    miter.setLength(-outset);
-                    miter += fPts[originalIdx];
-
-                    // For very shallow angles all the corner points could fuse
-                    if (!duplicate_pt(miter, this->point(perp1Idx))) {
-                        int miterIdx;
-                        miterIdx = this->addPt(miter, -outset, coverage, false, false);
-                        nextRing->addIdx(miterIdx, originalIdx);
-                        // The two triangles for the corner
-                        this->addTri(originalIdx, perp1Idx, miterIdx);
-                        this->addTri(originalIdx, miterIdx, perp2Idx);
-                    }
-                } else {
-                    this->addTri(originalIdx, perp1Idx, perp2Idx);
-                }
+        if (fIsCurve[cur]) {
+            // Inside a curve, we assume that the curvature is shallow enough (due to tesselation) 
+            // that we only need one corner point. Mathematically, the distance the corner point 
+            // gets shifted out should depend on the angle between the two line segments (as in 
+            // mitering), but again due to tesselation we assume that this angle is small and 
+            // therefore the correction factor is negligible and we do not bother with it.
+
+            // The bisector outset point
+            SkPoint temp = fBisectors[cur];
+            temp.scale(-fTargetDepth);  // the bisectors point in
+            temp += fPts[cur];
+
+            // double-check our "sufficiently flat" assumption; we want the bisector point to be
+            // close to the normal point.
+            #define kFlatnessTolerance 1.0f
+            SkDEBUGCODE(SkPoint prevNormal = fNorms[prev];)
+            SkDEBUGCODE(prevNormal.scale(fTargetDepth);)
+            SkDEBUGCODE(prevNormal += fPts[cur];)
+            SkASSERT((temp - prevNormal).length() < kFlatnessTolerance);
+
+            newIdx1 = this->addPt(temp, -fTargetDepth, false, true);
+
+            if (0 == cur) {
+                // Store the index of the first perpendicular point to finish up
+                firstPerpIdx = newIdx1;
+                SkASSERT(-1 == lastPerpIdx);
             } else {
-                switch (fJoin) {
-                    case SkPaint::Join::kMiter_Join: {
-                        // The bisector outset point
-                        SkPoint miter = previousRing.bisector(cur);
-                        SkScalar dotProd = normal1.dot(normal2);
-                        SkScalar sinHalfAngleSq = SkScalarHalf(SK_Scalar1 + dotProd);
-                        SkScalar lengthSq = outsetSq / sinHalfAngleSq;
-                        if (lengthSq > miterLimitSq) {
-                            // just bevel it
-                            this->addTri(originalIdx, perp1Idx, perp2Idx);
-                            break;
-                        }
-                        miter.setLength(-SkScalarSqrt(lengthSq));
-                        miter += fPts[originalIdx];
-
-                        // For very shallow angles all the corner points could fuse
-                        if (!duplicate_pt(miter, this->point(perp1Idx))) {
-                            int miterIdx;
-                            miterIdx = this->addPt(miter, -outset, coverage, false, false);
-                            nextRing->addIdx(miterIdx, originalIdx);
-                            // The two triangles for the corner
-                            this->addTri(originalIdx, perp1Idx, miterIdx);
-                            this->addTri(originalIdx, miterIdx, perp2Idx);
-                        }
-                        break;
-                    }
-                    case SkPaint::Join::kBevel_Join:
-                        this->addTri(originalIdx, perp1Idx, perp2Idx);
-                        break;
-                    default:
-                        // kRound_Join is unsupported for now. GrAALinearizingConvexPathRenderer is 
-                        // only willing to draw mitered or beveled, so we should never get here.
-                        SkASSERT(false);
-                }
+                // The triangles for the previous edge
+                this->addTri(prev, newIdx1, cur);
+                this->addTri(prev, lastPerpIdx, newIdx1);
             }
 
-            nextRing->addIdx(perp2Idx, originalIdx);
-        }
-
-        if (0 == cur) {
-            // Store the index of the first perpendicular point to finish up
-            firstPerpIdx = perp1Idx;
-            SkASSERT(-1 == lastPerpIdx);
-        } else {
-            // The triangles for the previous edge
-            int prevIdx = previousRing.index(prev);
-            this->addTri(prevIdx, perp1Idx, originalIdx);
-            this->addTri(prevIdx, lastPerpIdx, perp1Idx);
-        }
-
-        // Track the last perpendicular outset point so we can construct the
-        // trailing edge triangles.
-        lastPerpIdx = perp2Idx;
-        prev = cur;
+            prev = cur;
+            // Track the last perpendicular outset point so we can construct the
+            // trailing edge triangles.
+            lastPerpIdx = newIdx1;
+        }
+        else {
+            // For each vertex of the original polygon we add three points to the 
+            // outset polygon - one extending perpendicular to each impinging edge
+            // and one along the bisector. Two triangles are added for each corner
+            // and two are added along each edge.
+
+            // The perpendicular point for the last edge
+            SkPoint temp = fNorms[prev];
+            temp.scale(fTargetDepth);
+            temp += fPts[cur];
+
+            // We know it isn't a duplicate of the prior point (since it and this
+            // one are just perpendicular offsets from the non-merged polygon points)
+            newIdx0 = this->addPt(temp, -fTargetDepth, false, false);
+
+            // The bisector outset point
+            temp = fBisectors[cur];
+            temp.scale(-fTargetDepth);  // the bisectors point in
+            temp += fPts[cur];
+
+            // For very shallow angles all the corner points could fuse
+            if (duplicate_pt(temp, this->point(newIdx0))) {
+                newIdx1 = newIdx0;
+            } else {
+                newIdx1 = this->addPt(temp, -fTargetDepth, false, false);
+            }
+
+            // The perpendicular point for the next edge.
+            temp = fNorms[cur];
+            temp.scale(fTargetDepth);
+            temp += fPts[cur];
+
+            // For very shallow angles all the corner points could fuse.
+            if (duplicate_pt(temp, this->point(newIdx1))) {
+                newIdx2 = newIdx1;
+            } else {
+                newIdx2 = this->addPt(temp, -fTargetDepth, false, false);
+            }
+
+            if (0 == cur) {
+                // Store the index of the first perpendicular point to finish up
+                firstPerpIdx = newIdx0;
+                SkASSERT(-1 == lastPerpIdx);
+            } else {
+                // The triangles for the previous edge
+                this->addTri(prev, newIdx0, cur);
+                this->addTri(prev, lastPerpIdx, newIdx0);
+            }
+
+            // The two triangles for the corner
+            this->addTri(cur, newIdx0, newIdx1);
+            this->addTri(cur, newIdx1, newIdx2);
+
+            prev = cur;
+            // Track the last perpendicular outset point so we can construct the
+            // trailing edge triangles.
+            lastPerpIdx = newIdx2;
+        }
     }
 
     // pick up the final edge rect
-    int lastIdx = previousRing.index(numPts - 1);
-    this->addTri(lastIdx, firstPerpIdx, previousRing.index(0));
-    this->addTri(lastIdx, lastPerpIdx, firstPerpIdx);
+    this->addTri(numPts - 1, firstPerpIdx, 0);
+    this->addTri(numPts - 1, lastPerpIdx, firstPerpIdx);
 
     this->validate();
 }
 
-// Something went wrong in the creation of the next ring. If we're filling the shape, just go ahead
-// and fan it.
+// Something went wrong in the creation of the next ring. Mark the last good
+// ring as being at the desired depth and fan it.
 void GrAAConvexTessellator::terminate(const Ring& ring) {
-    if (fStrokeWidth < 0.0f) {
-        this->fanRing(ring);
-    }
-}
-
-static SkScalar compute_coverage(SkScalar depth, SkScalar initialDepth, SkScalar initialCoverage, 
-                                SkScalar targetDepth, SkScalar targetCoverage) {
-    if (SkScalarNearlyEqual(initialDepth, targetDepth)) {
-        return targetCoverage;
-    }
-    SkScalar result = (depth - initialDepth) / (targetDepth - initialDepth) * 
-            (targetCoverage - initialCoverage) + initialCoverage;
-    return SkScalarClampMax(result, 1.0f);
+    for (int i = 0; i < ring.numPts(); ++i) {
+        fDepths[ring.index(i)] = fTargetDepth;
+    }
+
+    this->fanRing(ring);
 }
 
 // return true when processing is complete
-bool GrAAConvexTessellator::createInsetRing(const Ring& lastRing, Ring* nextRing, 
-                                            SkScalar initialDepth, SkScalar initialCoverage, 
-                                            SkScalar targetDepth, SkScalar targetCoverage, 
-                                            bool forceNew) {
+bool GrAAConvexTessellator::createInsetRing(const Ring& lastRing, Ring* nextRing) {
     bool done = false;
 
     fCandidateVerts.rewind();
@@ -594,6 +512,7 @@
 
     for (int cur = 0; cur < lastRing.numPts(); ++cur) {
         int next = (cur + 1) % lastRing.numPts();
+
         SkScalar t = intersect(this->point(lastRing.index(cur)),  lastRing.bisector(cur),
                                this->point(lastRing.index(next)), lastRing.bisector(next));
         SkScalar dist = -t * lastRing.norm(cur).dot(lastRing.bisector(cur));
@@ -605,18 +524,15 @@
         }
     }
 
-    if (minEdgeIdx == -1) {
-        return false;
-    }
     SkPoint newPt = lastRing.bisector(minEdgeIdx);
     newPt.scale(minT);
     newPt += this->point(lastRing.index(minEdgeIdx));
 
     SkScalar depth = this->computeDepthFromEdge(lastRing.origEdgeID(minEdgeIdx), newPt);
-    if (depth >= targetDepth) {
+    if (depth >= fTargetDepth) {
         // None of the bisectors intersect before reaching the desired depth.
         // Just step them all to the desired depth
-        depth = targetDepth;
+        depth = fTargetDepth;
         done = true;
     }
 
@@ -631,6 +547,7 @@
                                       lastRing.origEdgeID(0),
                                       depth, &newPt)) {
         this->terminate(lastRing);
+        SkDEBUGCODE(fShouldCheckDepths = false;)
         return true;
     }
     dst[0] = fCandidateVerts.addNewPt(newPt,
@@ -644,6 +561,7 @@
                                           lastRing.origEdgeID(cur),
                                           depth, &newPt)) {
             this->terminate(lastRing);
+            SkDEBUGCODE(fShouldCheckDepths = false;)
             return true;
         }
         if (!duplicate_pt(newPt, fCandidateVerts.lastPoint())) {
@@ -662,6 +580,7 @@
                                        lastRing.origEdgeID(cur),
                                        depth, &newPt)) {
         this->terminate(lastRing);
+        SkDEBUGCODE(fShouldCheckDepths = false;)
         return true;
     }
     bool dupPrev = duplicate_pt(newPt, fCandidateVerts.lastPoint());
@@ -688,17 +607,14 @@
     // Fold the new ring's points into the global pool
     for (int i = 0; i < fCandidateVerts.numPts(); ++i) {
         int newIdx;
-        if (fCandidateVerts.needsToBeNew(i) || forceNew) {
+        if (fCandidateVerts.needsToBeNew(i)) {
             // if the originating index is still valid then this point wasn't 
             // fused (and is thus movable)
-            SkScalar coverage = compute_coverage(depth, initialDepth, initialCoverage, 
-                                                 targetDepth, targetCoverage);
-            newIdx = this->addPt(fCandidateVerts.point(i), depth, coverage,
+            newIdx = this->addPt(fCandidateVerts.point(i), depth,
                                  fCandidateVerts.originatingIdx(i) != -1, false);
         } else {
             SkASSERT(fCandidateVerts.originatingIdx(i) != -1);
-            this->updatePt(fCandidateVerts.originatingIdx(i), fCandidateVerts.point(i), depth,
-                           targetCoverage);
+            this->updatePt(fCandidateVerts.originatingIdx(i), fCandidateVerts.point(i), depth);
             newIdx = fCandidateVerts.originatingIdx(i);
         }
 
@@ -718,18 +634,19 @@
         this->addTri(lastRing.index(cur), dst[next], dst[cur]);
     }
 
-    if (done && fStrokeWidth < 0.0f) {
-        // fill
+    if (done) {
         this->fanRing(*nextRing);
     }
 
     if (nextRing->numPts() < 3) {
         done = true;
     }
+
     return done;
 }
 
 void GrAAConvexTessellator::validate() const {
+    SkASSERT(fPts.count() == fDepths.count());
     SkASSERT(fPts.count() == fMovable.count());
     SkASSERT(0 == (fIndices.count() % 3));
 }
@@ -738,6 +655,7 @@
 void GrAAConvexTessellator::Ring::init(const GrAAConvexTessellator& tess) {
     this->computeNormals(tess);
     this->computeBisectors(tess);
+    SkASSERT(this->isConvex(tess));
 }
 
 void GrAAConvexTessellator::Ring::init(const SkTDArray<SkVector>& norms,
@@ -754,8 +672,11 @@
         int next = (cur + 1) % fPts.count();
 
         fPts[cur].fNorm = tess.point(fPts[next].fIndex) - tess.point(fPts[cur].fIndex);
-        SkPoint::Normalize(&fPts[cur].fNorm);
+        SkDEBUGCODE(SkScalar len =) SkPoint::Normalize(&fPts[cur].fNorm);
+        SkASSERT(len > 0.0f);
         fPts[cur].fNorm.setOrthog(fPts[cur].fNorm, tess.side());
+
+        SkASSERT(SkScalarNearlyEqual(1.0f, fPts[cur].fNorm.length()));
     }
 }
 
@@ -773,7 +694,9 @@
         } else {
             fPts[cur].fBisector.negate();      // make the bisector face in
         }
-    }
+
+        SkASSERT(SkScalarNearlyEqual(1.0f, fPts[cur].fBisector.length()));
+    }    
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -781,7 +704,7 @@
 // Is this ring convex?
 bool GrAAConvexTessellator::Ring::isConvex(const GrAAConvexTessellator& tess) const {
     if (fPts.count() < 3) {
-        return true;
+        return false;
     }
 
     SkPoint prev = tess.point(fPts[0].fIndex) - tess.point(fPts.top().fIndex);
@@ -802,18 +725,74 @@
         prev = cur;
     }
 
-    if (SkScalarNearlyEqual(maxDot, 0.0f, 0.005f)) {
-        maxDot = 0;
-    }
-    if (SkScalarNearlyEqual(minDot, 0.0f, 0.005f)) {
-        minDot = 0;
-    }
-    return (maxDot >= 0.0f) == (minDot >= 0.0f);
-}
-
+    return (maxDot > 0.0f) == (minDot >= 0.0f);
+}
+
+static SkScalar capsule_depth(const SkPoint& p0, const SkPoint& p1,
+                              const SkPoint& test, SkPoint::Side side,
+                              int* sign) {
+    *sign = -1;
+    SkPoint edge = p1 - p0;
+    SkScalar len = SkPoint::Normalize(&edge);
+
+    SkPoint testVec = test - p0;
+
+    SkScalar d0 = edge.dot(testVec);
+    if (d0 < 0.0f) {
+        return SkPoint::Distance(p0, test);
+    }
+    if (d0 > len) {
+        return SkPoint::Distance(p1, test);
+    }
+
+    SkScalar perpDist = testVec.fY * edge.fX - testVec.fX * edge.fY;
+    if (SkPoint::kRight_Side == side) {
+        perpDist = -perpDist;
+    }
+
+    if (perpDist < 0.0f) {
+        perpDist = -perpDist;
+    } else {
+        *sign = 1;
+    }
+    return perpDist;
+}
+
+SkScalar GrAAConvexTessellator::computeRealDepth(const SkPoint& p) const {
+    SkScalar minDist = SK_ScalarMax;
+    int closestSign, sign;
+
+    for (int edge = 0; edge < fNorms.count(); ++edge) {
+        SkScalar dist = capsule_depth(this->point(edge),
+                                      this->point((edge+1) % fNorms.count()),
+                                      p, fSide, &sign);
+        SkASSERT(dist >= 0.0f);
+
+        if (minDist > dist) {
+            minDist = dist;
+            closestSign = sign;
+        }
+    }
+
+    return closestSign * minDist;
+}
+
+// Verify that the incrementally computed depths are close to the actual depths.
+void GrAAConvexTessellator::checkAllDepths() const {
+    for (int cur = 0; cur < this->numPts(); ++cur) {
+        SkScalar realDepth = this->computeRealDepth(this->point(cur));
+        SkScalar computedDepth = this->depth(cur);
+        SkASSERT(SkScalarNearlyEqual(realDepth, computedDepth, 0.01f));
+    }
+}
 #endif
 
-void GrAAConvexTessellator::lineTo(SkPoint p, bool isCurve) {
+#define kQuadTolerance 0.2f
+#define kCubicTolerance 0.2f
+#define kConicTolerance 0.5f
+
+void GrAAConvexTessellator::lineTo(const SkMatrix& m, SkPoint p, bool isCurve) {
+    m.mapPoints(&p, 1);
     if (this->numPts() > 0 && duplicate_pt(p, this->lastPoint())) {
         return;
     }
@@ -826,22 +805,24 @@
         fNorms.pop();
         fIsCurve.pop();
     }
-    SkScalar initialRingCoverage = fStrokeWidth < 0.0f ? 0.5f : 1.0f;
-    this->addPt(p, 0.0f, initialRingCoverage, false, isCurve);
+    this->addPt(p, 0.0f, false, isCurve);
     if (this->numPts() > 1) {
         *fNorms.push() = fPts.top() - fPts[fPts.count()-2];
         SkDEBUGCODE(SkScalar len =) SkPoint::Normalize(&fNorms.top());
         SkASSERT(len > 0.0f);
         SkASSERT(SkScalarNearlyEqual(1.0f, fNorms.top().length()));
     }
-}
-
-void GrAAConvexTessellator::lineTo(const SkMatrix& m, SkPoint p, bool isCurve) {
-    m.mapPoints(&p, 1);
-    this->lineTo(p, isCurve);
-}
-
-void GrAAConvexTessellator::quadTo(SkPoint pts[3]) {
+    SkDEBUGCODE(
+        if (this->numPts() >= 3) {
+            int cur = this->numPts()-1;
+            SkScalar cross = SkPoint::CrossProduct(fNorms[cur-1], fNorms[cur-2]);
+            fMaxCross = SkTMax(fMaxCross, cross);
+            fMinCross = SkTMin(fMinCross, cross);
+        }
+    )
+}
+
+void GrAAConvexTessellator::quadTo(const SkMatrix& m, SkPoint pts[3]) {
     int maxCount = GrPathUtils::quadraticPointCount(pts, kQuadTolerance);
     fPointBuffer.setReserve(maxCount);
     SkPoint* target = fPointBuffer.begin();
@@ -849,21 +830,11 @@
             kQuadTolerance, &target, maxCount);
     fPointBuffer.setCount(count);
     for (int i = 0; i < count; i++) {
-        lineTo(fPointBuffer[i], true);
-    }
-}
-
-void GrAAConvexTessellator::quadTo(const SkMatrix& m, SkPoint pts[3]) {
-    SkPoint transformed[3];
-    transformed[0] = pts[0];
-    transformed[1] = pts[1];
-    transformed[2] = pts[2];
-    m.mapPoints(transformed, 3);
-    quadTo(transformed);
+        lineTo(m, fPointBuffer[i], true);
+    }
 }
 
 void GrAAConvexTessellator::cubicTo(const SkMatrix& m, SkPoint pts[4]) {
-    m.mapPoints(pts, 4);
     int maxCount = GrPathUtils::cubicPointCount(pts, kCubicTolerance);
     fPointBuffer.setReserve(maxCount);
     SkPoint* target = fPointBuffer.begin();
@@ -871,15 +842,14 @@
             kCubicTolerance, &target, maxCount);
     fPointBuffer.setCount(count);
     for (int i = 0; i < count; i++) {
-        lineTo(fPointBuffer[i], true);
+        lineTo(m, fPointBuffer[i], true);
     }
 }
 
 // include down here to avoid compilation errors caused by "-" overload in SkGeometry.h
 #include "SkGeometry.h"
 
-void GrAAConvexTessellator::conicTo(const SkMatrix& m, SkPoint pts[3], SkScalar w) {
-    m.mapPoints(pts, 3);
+void GrAAConvexTessellator::conicTo(const SkMatrix& m, SkPoint* pts, SkScalar w) {
     SkAutoConicToQuads quadder;
     const SkPoint* quads = quadder.computeQuads(pts, w, kConicTolerance);
     SkPoint lastPoint = *(quads++);
@@ -889,7 +859,7 @@
         quadPts[0] = lastPoint;
         quadPts[1] = quads[0];
         quadPts[2] = i == count - 1 ? pts[2] : quads[1];
-        quadTo(quadPts);
+        quadTo(m, quadPts);
         lastPoint = quadPts[2];
         quads += 2;
     }
@@ -995,13 +965,13 @@
 
     for (int i = 0; i < this->numPts(); ++i) {
         draw_point(canvas,
-                   this->point(i), 0.5f + (this->depth(i)/(2 * kAntialiasingRadius)), 
+                   this->point(i), 0.5f + (this->depth(i)/(2*fTargetDepth)), 
                    !this->movable(i));
 
         SkPaint paint;
         paint.setTextSize(kPointTextSize);
         paint.setTextAlign(SkPaint::kCenter_Align);
-        if (this->depth(i) <= -kAntialiasingRadius) {
+        if (this->depth(i) <= -fTargetDepth) {
             paint.setColor(SK_ColorWHITE);
         }