Revert of pathops version two (patchset #16 id:150001 of https://codereview.chromium.org/1002693002/)

Reason for revert:
ASAN investigation

Original issue's description:
> pathops version two
>
> R=reed@google.com
>
> marked 'no commit' to attempt to get trybots to run
>
> TBR=reed@google.com
>
> Committed: https://skia.googlesource.com/skia/+/ccec0f958ffc71a9986d236bc2eb335cb2111119

TBR=caryclark@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1029993002

1 files changed, 518 insertions, 820 deletions

diff --git a/tests/PathOpsDebug.cpp b/tests/PathOpsDebug.cpp
index 9930453d01..c4fbbfa695 100755
--- a/tests/PathOpsDebug.cpp
+++ b/tests/PathOpsDebug.cpp
@@ -1,12 +1,3 @@
-/*
- * 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 "PathOpsTSectDebug.h"
-#include "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkIntersectionHelper.h"
 #include "SkOpSegment.h"
@@ -59,6 +50,7 @@ static void output_points(const SkPoint* pts, int count) {
             SkDebugf(", ");
         }
     }
+    SkDebugf(");\n");
 }
 
 static void showPathContours(SkPath::RawIter& iter, const char* pathName) {
@@ -69,27 +61,18 @@ static void showPathContours(SkPath::RawIter& iter, const char* pathName) {
             case SkPath::kMove_Verb:
                 SkDebugf("    %s.moveTo(", pathName);
                 output_points(&pts[0], 1);
-                SkDebugf(");\n");
                 continue;
             case SkPath::kLine_Verb:
                 SkDebugf("    %s.lineTo(", pathName);
                 output_points(&pts[1], 1);
-                SkDebugf(");\n");
                 break;
             case SkPath::kQuad_Verb:
                 SkDebugf("    %s.quadTo(", pathName);
                 output_points(&pts[1], 2);
-                SkDebugf(");\n");
-                break;
-            case SkPath::kConic_Verb:
-                SkDebugf("    %s.conicTo(", pathName);
-                output_points(&pts[1], 2);
-                SkDebugf(", %1.9gf);\n", iter.conicWeight());
                 break;
             case SkPath::kCubic_Verb:
                 SkDebugf("    %s.cubicTo(", pathName);
                 output_points(&pts[1], 3);
-                SkDebugf(");\n");
                 break;
             case SkPath::kClose_Verb:
                 SkDebugf("    %s.close();\n", pathName);
@@ -185,393 +168,6 @@ void SkPathOpsDebug::WindingPrintf(int wind) {
 }
 #endif
 
-void SkDCubic::dump() const {
-    dumpInner();
-    SkDebugf("}},\n");
-}
-
-void SkDCubic::dumpID(int id) const {
-    dumpInner();
-    SkDebugf("}} id=%d\n", id);
-}
-
-static inline bool double_is_NaN(double x) { return x != x; }
-
-void SkDCubic::dumpInner() const {
-    SkDebugf("{{");
-    int index = 0;
-    do {
-        if (index != 0) {
-            if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
-                return;
-            }
-            SkDebugf(", ");
-        }
-        fPts[index].dump();
-    } while (++index < 3);
-    if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
-        return;
-    }
-    SkDebugf(", ");
-    fPts[index].dump();
-}
-
-void SkDLine::dump() const {
-    SkDebugf("{{");
-    fPts[0].dump();
-    SkDebugf(", ");
-    fPts[1].dump();
-    SkDebugf("}},\n");
-}
-
-void SkDPoint::dump() const {
-    SkDebugf("{");
-    DebugDumpDouble(fX);
-    SkDebugf(", ");
-    DebugDumpDouble(fY);
-    SkDebugf("}");
-}
-
-void SkDPoint::Dump(const SkPoint& pt) {
-    SkDebugf("{");
-    DebugDumpFloat(pt.fX);
-    SkDebugf(", ");
-    DebugDumpFloat(pt.fY);
-    SkDebugf("}");
-}
-
-void SkDPoint::DumpHex(const SkPoint& pt) {
-    SkDebugf("{");
-    DebugDumpHexFloat(pt.fX);
-    SkDebugf(", ");
-    DebugDumpHexFloat(pt.fY);
-    SkDebugf("}");
-}
-
-void SkDQuad::dump() const {
-    dumpInner();
-    SkDebugf("}},\n");
-}
-
-void SkDQuad::dumpID(int id) const {
-    dumpInner();
-    SkDebugf("}} id=%d\n", id);
-}
-
-void SkDQuad::dumpInner() const {
-    SkDebugf("{{");
-    int index = 0;
-    do {
-        fPts[index].dump();
-        SkDebugf(", ");
-    } while (++index < 2);
-    fPts[index].dump();
-}
-
-void SkIntersections::dump() const {
-    SkDebugf("used=%d of %d", fUsed, fMax);
-    for (int index = 0; index < fUsed; ++index) {
-        SkDebugf(" t=(%s%1.9g,%s%1.9g) pt=(%1.9g,%1.9g)",
-                fIsCoincident[0] & (1 << index) ? "*" : "", fT[0][index],
-                fIsCoincident[1] & (1 << index) ? "*" : "", fT[1][index],
-                fPt[index].fX, fPt[index].fY);
-        if (index < 2 && fNearlySame[index]) {
-            SkDebugf(" pt2=(%1.9g,%1.9g)",fPt2[index].fX, fPt2[index].fY);
-        }
-    }
-    SkDebugf("\n");
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugAngleAngle(const SkOpAngle* angle, int id) {
-    return angle->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugAngleContour(SkOpAngle* angle, int id) {
-    return angle->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugAnglePtT(const SkOpAngle* angle, int id) {
-    return angle->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugAngleSegment(const SkOpAngle* angle, int id) {
-    return angle->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugAngleSpan(const SkOpAngle* angle, int id) {
-    return angle->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugContourAngle(SkOpContour* contour, int id) {
-    return contour->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugContourContour(SkOpContour* contour, int id) {
-    return contour->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugContourPtT(SkOpContour* contour, int id) {
-    return contour->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugContourSegment(SkOpContour* contour, int id) {
-    return contour->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugContourSpan(SkOpContour* contour, int id) {
-    return contour->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugPtTAngle(const SkOpPtT* ptT, int id) {
-    return ptT->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugPtTContour(SkOpPtT* ptT, int id) {
-    return ptT->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugPtTPtT(const SkOpPtT* ptT, int id) {
-    return ptT->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugPtTSegment(const SkOpPtT* ptT, int id) {
-    return ptT->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugPtTSpan(const SkOpPtT* ptT, int id) {
-    return ptT->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugSegmentAngle(const SkOpSegment* span, int id) {
-    return span->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugSegmentContour(SkOpSegment* span, int id) {
-    return span->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugSegmentPtT(const SkOpSegment* span, int id) {
-    return span->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugSegmentSegment(const SkOpSegment* span, int id) {
-    return span->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugSegmentSpan(const SkOpSegment* span, int id) {
-    return span->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugSpanAngle(const SkOpSpanBase* span, int id) {
-    return span->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugSpanContour(SkOpSpanBase* span, int id) {
-    return span->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugSpanPtT(const SkOpSpanBase* span, int id) {
-    return span->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugSpanSegment(const SkOpSpanBase* span, int id) {
-    return span->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugSpanSpan(const SkOpSpanBase* span, int id) {
-    return span->debugSpan(id);
-}
-
-void SkPathOpsDebug::DumpContours(SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dump();
-    }
-}
-
-void SkPathOpsDebug::DumpContoursAll(SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpAll();
-    }
-}
-
-void SkPathOpsDebug::DumpContoursAngles(const SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpAngles();
-    }
-}
-
-void SkPathOpsDebug::DumpContoursPts(const SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpPts();
-    }
-}
-
-void SkPathOpsDebug::DumpContoursPt(const SkTDArray<SkOpContour* >* contours, int segmentID) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpPt(segmentID);
-    }
-}
-
-void SkPathOpsDebug::DumpContoursSegment(const SkTDArray<SkOpContour* >* contours,
-        int segmentID) {
-    if (contours->count()) {
-        (*contours)[0]->dumpSegment(segmentID);
-    }
-}
-
-void SkPathOpsDebug::DumpContoursSpan(const SkTDArray<SkOpContour* >* contours,
-        int spanID) {
-    if (contours->count()) {
-        (*contours)[0]->dumpSpan(spanID);
-    }
-}
-
-void SkPathOpsDebug::DumpContoursSpans(const SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpSpans();
-    }
-}
-
-const SkTSpan<SkDCubic>* DebugSpan(const SkTSect<SkDCubic>* sect, int id) {
-    return sect->debugSpan(id);
-}
-
-const SkTSpan<SkDQuad>* DebugSpan(const SkTSect<SkDQuad>* sect, int id) {
-    return sect->debugSpan(id);
-}
-
-const SkTSpan<SkDCubic>* DebugT(const SkTSect<SkDCubic>* sect, double t) {
-    return sect->debugT(t);
-}
-
-const SkTSpan<SkDQuad>* DebugT(const SkTSect<SkDQuad>* sect, double t) {
-    return sect->debugT(t);
-}
-
-const SkTSpan<SkDCubic>* DebugSpan(const SkTSpan<SkDCubic>* span, int id) {
-    return span->debugSpan(id);
-}
-
-const SkTSpan<SkDQuad>* DebugSpan(const SkTSpan<SkDQuad>* span, int id) {
-    return span->debugSpan(id);
-}
-
-const SkTSpan<SkDCubic>* DebugT(const SkTSpan<SkDCubic>* span, double t) {
-    return span->debugT(t);
-}
-
-const SkTSpan<SkDQuad>* DebugT(const SkTSpan<SkDQuad>* span, double t) {
-    return span->debugT(t);
-}
-
-void Dump(const SkTSect<SkDCubic>* sect) {
-    sect->dump();
-}
-
-void Dump(const SkTSect<SkDQuad>* sect) {
-    sect->dump();
-}
-
-void Dump(const SkTSpan<SkDCubic>* span) {
-    span->dump();
-}
-
-void Dump(const SkTSpan<SkDQuad>* span) {
-    span->dump();
-}
-
-void DumpBoth(SkTSect<SkDCubic>* sect1, SkTSect<SkDCubic>* sect2) {
-    sect1->dumpBoth(sect2);
-}
-
-void DumpBoth(SkTSect<SkDQuad>* sect1, SkTSect<SkDQuad>* sect2) {
-    sect1->dumpBoth(sect2);
-}
-
-void DumpCoin(SkTSect<SkDCubic>* sect1) {
-    sect1->dumpCoin();
-}
-
-void DumpCoin(SkTSect<SkDQuad>* sect1) {
-    sect1->dumpCoin();
-}
-
-void DumpCoinCurves(SkTSect<SkDCubic>* sect1) {
-    sect1->dumpCoinCurves();
-}
-
-void DumpCoinCurves(SkTSect<SkDQuad>* sect1) {
-    sect1->dumpCoinCurves();
-}
-
-void DumpCurves(const SkTSect<SkDQuad>* sect) {
-    sect->dumpCurves();
-}
-
-void DumpCurves(const SkTSect<SkDCubic>* sect) {
-    sect->dumpCurves();
-}
-
-static void dumpTestCase(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
-    SkDebugf("\n<div id=\"quad%d\">\n", testNo);
-    quad1.dumpInner();
-    SkDebugf("}}, ");
-    quad2.dump();
-    SkDebugf("</div>\n\n");
-}
-
-static void dumpTestTrailer() {
-    SkDebugf("</div>\n\n<script type=\"text/javascript\">\n\n");
-    SkDebugf("    var testDivs = [\n");
-}
-
-static void dumpTestList(int testNo, double min) {
-    SkDebugf("        quad%d,", testNo);
-    if (min > 0) {
-        SkDebugf("  // %1.9g", min);
-    }
-    SkDebugf("\n");
-}
-
-void DumpQ(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
-    SkDebugf("\n");
-    dumpTestCase(quad1, quad2, testNo);
-    dumpTestTrailer();
-    dumpTestList(testNo, 0);
-    SkDebugf("\n");
-}
-
-void DumpT(const SkDQuad& quad, double t) {
-    SkDLine line = {{quad.ptAtT(t), quad[0]}};
-    line.dump();
-}
-
-const SkOpAngle* SkOpAngle::debugAngle(int id) const {
-    return this->segment()->debugAngle(id);
-}
-
-SkOpContour* SkOpAngle::debugContour(int id) {
-    return this->segment()->debugContour(id);
-}
-
-const SkOpPtT* SkOpAngle::debugPtT(int id) const {
-    return this->segment()->debugPtT(id);
-}
-
-const SkOpSegment* SkOpAngle::debugSegment(int id) const {
-    return this->segment()->debugSegment(id);
-}
-
-const SkOpSpanBase* SkOpAngle::debugSpan(int id) const {
-    return this->segment()->debugSpan(id);
-}
-
 void SkOpAngle::dump() const {
     dumpOne(true);
     SkDebugf("\n");
@@ -579,39 +175,44 @@ void SkOpAngle::dump() const {
 
 void SkOpAngle::dumpOne(bool functionHeader) const {
 //    fSegment->debugValidate();
-    const SkOpSegment* segment = this->segment();
-    const SkOpSpan& mSpan = *fStart->starter(fEnd);
+    const SkOpSpan& mSpan = fSegment->span(SkMin32(fStart, fEnd));
     if (functionHeader) {
         SkDebugf("%s ", __FUNCTION__);
     }
-    SkDebugf("[%d", segment->debugID());
+    SkDebugf("[%d", fSegment->debugID());
     SkDebugf("/%d", debugID());
     SkDebugf("] next=");
     if (fNext) {
-        SkDebugf("%d", fNext->fStart->segment()->debugID());
+        SkDebugf("%d", fNext->fSegment->debugID());
         SkDebugf("/%d", fNext->debugID());
     } else {
         SkDebugf("?");
     }
     SkDebugf(" sect=%d/%d ", fSectorStart, fSectorEnd);
-    SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fStart->t(), fStart->debugID(),
-                fEnd->t(), fEnd->debugID());
-    SkDebugf(" sgn=%d windVal=%d", this->sign(), mSpan.windValue());
+    SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fSegment->span(fStart).fT, fStart,
+            fSegment->span(fEnd).fT, fEnd);
+    SkDebugf(" sgn=%d windVal=%d", sign(), mSpan.fWindValue);
 
     SkDebugf(" windSum=");
-    SkPathOpsDebug::WindingPrintf(mSpan.windSum());
-    if (mSpan.oppValue() != 0 || mSpan.oppSum() != SK_MinS32) {
-        SkDebugf(" oppVal=%d", mSpan.oppValue());
+    SkPathOpsDebug::WindingPrintf(mSpan.fWindSum);
+    if (mSpan.fOppValue != 0 || mSpan.fOppSum != SK_MinS32) {
+        SkDebugf(" oppVal=%d", mSpan.fOppValue);
         SkDebugf(" oppSum=");
-        SkPathOpsDebug::WindingPrintf(mSpan.oppSum());
+        SkPathOpsDebug::WindingPrintf(mSpan.fOppSum);
     }
-    if (mSpan.done()) {
+    if (mSpan.fDone) {
         SkDebugf(" done");
     }
     if (unorderable()) {
         SkDebugf(" unorderable");
     }
-    if (segment->operand()) {
+    if (small()) {
+        SkDebugf(" small");
+    }
+    if (mSpan.fTiny) {
+        SkDebugf(" tiny");
+    }
+    if (fSegment->operand()) {
         SkDebugf(" operand");
     }
     if (fStop) {
@@ -626,7 +227,7 @@ void SkOpAngle::dumpTo(const SkOpSegment* segment, const SkOpAngle* to) const {
     do {
         SkDebugf("%s", indent);
         next->dumpOne(false);
-        if (segment == next->fStart->segment()) {
+        if (segment == next->fSegment) {
             if (this == fNext) {
                 SkDebugf(" << from");
             }
@@ -640,15 +241,6 @@ void SkOpAngle::dumpTo(const SkOpSegment* segment, const SkOpAngle* to) const {
     } while (next && next != first);
 }
 
-void SkOpAngle::dumpCurves() const {
-    const SkOpAngle* first = this;
-    const SkOpAngle* next = this;
-    do {
-        next->fCurvePart.dumpID(next->segment()->debugID());
-        next = next->fNext;
-    } while (next && next != first);
-}
-
 void SkOpAngle::dumpLoop() const {
     const SkOpAngle* first = this;
     const SkOpAngle* next = this;
@@ -659,541 +251,647 @@ void SkOpAngle::dumpLoop() const {
     } while (next && next != first);
 }
 
-void SkOpAngle::dumpTest() const {
+void SkOpAngle::dumpPartials() const {
     const SkOpAngle* first = this;
     const SkOpAngle* next = this;
     do {
-        SkDebugf("{ ");
-        SkOpSegment* segment = next->segment();
-        segment->dumpPts();
-        SkDebugf(", %d, %1.9g, %1.9g, {} },\n", SkPathOpsVerbToPoints(segment->verb()) + 1,
-                next->start()->t(), next->end()->t());
+        next->fCurvePart.dumpNumber();
         next = next->fNext;
     } while (next && next != first);
 }
 
-bool SkOpPtT::debugMatchID(int id) const {
-    int limit = this->debugLoopLimit(false);
-    int loop = 0;
-    const SkOpPtT* ptT = this;
-    do {
-        if (ptT->debugID() == id) {
-            return true;
+void SkOpAngleSet::dump() const {
+    // FIXME: unimplemented
+/* This requires access to the internal SkChunkAlloc data
+   Defer implementing this until it is needed for debugging
+*/
+    SkASSERT(0);
+}
+
+void SkOpContour::dump() const {
+    int segmentCount = fSegments.count();
+    SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
+    for (int test = 0; test < segmentCount; ++test) {
+        SkDebugf("  [%d] ((SkOpSegment*) 0x%p) [%d]\n", test, &fSegments[test],
+                fSegments[test].debugID());
+    }
+}
+
+void SkOpContour::dumpAngles() const {
+    int segmentCount = fSegments.count();
+    SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
+    for (int test = 0; test < segmentCount; ++test) {
+        SkDebugf("  [%d] ", test);
+        fSegments[test].dumpAngles();
+    }
+}
+
+void SkOpContour::dumpCoincidence(const SkCoincidence& coin) const {
+    int thisIndex = coin.fSegments[0];
+    const SkOpSegment& s1 = fSegments[thisIndex];
+    int otherIndex = coin.fSegments[1];
+    const SkOpSegment& s2 = coin.fOther->fSegments[otherIndex];
+    SkDebugf("((SkOpSegment*) 0x%p) [%d]  ((SkOpSegment*) 0x%p) [%d]\n", &s1, s1.debugID(),
+            &s2, s2.debugID());
+    for (int index = 0; index < 2; ++index) {
+        SkDebugf("    {%1.9gf, %1.9gf}", coin.fPts[0][index].fX, coin.fPts[0][index].fY);
+        if (coin.fNearly[index]) {
+            SkDebugf("    {%1.9gf, %1.9gf}", coin.fPts[1][index].fX, coin.fPts[1][index].fY);
         }
-    } while ((!limit || ++loop <= limit) && (ptT = ptT->next()) && ptT != this);
-    return false;
+        SkDebugf("  seg1t=%1.9g seg2t=%1.9g\n", coin.fTs[0][index], coin.fTs[1][index]);
+    }
 }
 
-const SkOpAngle* SkOpPtT::debugAngle(int id) const {
-    return this->span()->debugAngle(id);
+void SkOpContour::dumpCoincidences() const {
+    int count = fCoincidences.count();
+    if (count > 0) {
+        SkDebugf("fCoincidences count=%d\n", count);
+        for (int test = 0; test < count; ++test) {
+            dumpCoincidence(fCoincidences[test]);
+        }
+    }
+    count = fPartialCoincidences.count();
+    if (count == 0) {
+        return;
+    }
+    SkDebugf("fPartialCoincidences count=%d\n", count);
+    for (int test = 0; test < count; ++test) {
+        dumpCoincidence(fPartialCoincidences[test]);
+    }
 }
 
-SkOpContour* SkOpPtT::debugContour(int id) {
-    return this->span()->debugContour(id);
+void SkOpContour::dumpPt(int index) const {
+    int segmentCount = fSegments.count();
+    for (int test = 0; test < segmentCount; ++test) {
+        const SkOpSegment& segment = fSegments[test];
+        if (segment.debugID() == index) {
+            fSegments[test].dumpPts();
+        }
+    }
 }
 
-const SkOpPtT* SkOpPtT::debugPtT(int id) const {
-    return this->span()->debugPtT(id);
+void SkOpContour::dumpPts() const {
+    int segmentCount = fSegments.count();
+    SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
+    for (int test = 0; test < segmentCount; ++test) {
+        SkDebugf("  [%d] ", test);
+        fSegments[test].dumpPts();
+    }
 }
 
-const SkOpSegment* SkOpPtT::debugSegment(int id) const {
-    return this->span()->debugSegment(id);
+void SkOpContour::dumpSpan(int index) const {
+    int segmentCount = fSegments.count();
+    for (int test = 0; test < segmentCount; ++test) {
+        const SkOpSegment& segment = fSegments[test];
+        if (segment.debugID() == index) {
+            fSegments[test].dumpSpans();
+        }
+    }
 }
 
-const SkOpSpanBase* SkOpPtT::debugSpan(int id) const {
-    return this->span()->debugSpan(id);
+void SkOpContour::dumpSpans() const {
+    int segmentCount = fSegments.count();
+    SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
+    for (int test = 0; test < segmentCount; ++test) {
+        SkDebugf("  [%d] ", test);
+        fSegments[test].dumpSpans();
+    }
 }
 
-void SkOpPtT::dump() const {
-    SkDebugf("seg=%d span=%d ptT=%d",
-            this->segment()->debugID(), this->span()->debugID(), this->debugID());
-    this->dumpBase();
-    SkDebugf("\n");
+void SkDCubic::dump() const {
+    SkDebugf("{{");
+    int index = 0;
+    do {
+        fPts[index].dump();
+        SkDebugf(", ");
+    } while (++index < 3);
+    fPts[index].dump();
+    SkDebugf("}}\n");
 }
 
-void SkOpPtT::dumpAll() const {
-    contour()->indentDump();
-    const SkOpPtT* next = this;
-    int limit = debugLoopLimit(true);
-    int loop = 0;
+void SkDCubic::dumpNumber() const {
+    SkDebugf("{{");
+    int index = 0;
+    bool dumpedOne = false;
     do {
-        SkDebugf("%.*s", contour()->debugIndent(), "        ");
-        SkDebugf("seg=%d span=%d ptT=%d",
-                next->segment()->debugID(), next->span()->debugID(), next->debugID());
-        next->dumpBase();
-        SkDebugf("\n");
-        if (limit && ++loop >= limit) {
-            SkDebugf("*** abort loop ***\n");
-            break;
+        if (!(fPts[index].fX == fPts[index].fX && fPts[index].fY == fPts[index].fY)) {
+            continue;
+        }
+        if (dumpedOne) {
+            SkDebugf(", ");
+        }
+        fPts[index].dump();
+        dumpedOne = true;
+    } while (++index < 3);
+    if (fPts[index].fX == fPts[index].fX && fPts[index].fY == fPts[index].fY) {
+        if (dumpedOne) {
+            SkDebugf(", ");
         }
-    } while ((next = next->fNext) && next != this);
-    contour()->outdentDump();
+        fPts[index].dump();
+    }
+    SkDebugf("}}\n");
 }
 
-void SkOpPtT::dumpBase() const {
-    SkDebugf(" t=%1.9g pt=(%1.9g,%1.9g)%s%s", this->fT, this->fPt.fX, this->fPt.fY,
-            this->fDuplicatePt ? " dup" : "", this->fDeleted ? " deleted" : "");
+void SkDLine::dump() const {
+    SkDebugf("{{");
+    fPts[0].dump();
+    SkDebugf(", ");
+    fPts[1].dump();
+    SkDebugf("}}\n");
 }
 
-const SkOpAngle* SkOpSpanBase::debugAngle(int id) const {
-    return this->segment()->debugAngle(id);
+void SkDPoint::dump() const {
+    SkDebugf("{");
+    DebugDumpDouble(fX);
+    SkDebugf(", ");
+    DebugDumpDouble(fY);
+    SkDebugf("}");
 }
 
-SkOpContour* SkOpSpanBase::debugContour(int id) {
-    return this->segment()->debugContour(id);
+void SkDPoint::Dump(const SkPoint& pt) {
+    SkDebugf("{");
+    DebugDumpFloat(pt.fX);
+    SkDebugf(", ");
+    DebugDumpFloat(pt.fY);
+    SkDebugf("}");
 }
 
-const SkOpPtT* SkOpSpanBase::debugPtT(int id) const {
-    return this->segment()->debugPtT(id);
+void SkDPoint::DumpHex(const SkPoint& pt) {
+    SkDebugf("{");
+    DebugDumpHexFloat(pt.fX);
+    SkDebugf(", ");
+    DebugDumpHexFloat(pt.fY);
+    SkDebugf("}");
 }
 
-const SkOpSegment* SkOpSpanBase::debugSegment(int id) const {
-    return this->segment()->debugSegment(id);
+void SkDQuad::dump() const {
+    dumpComma("");
 }
 
-const SkOpSpanBase* SkOpSpanBase::debugSpan(int id) const {
-    return this->segment()->debugSpan(id);
+void SkDQuad::dumpComma(const char* comma) const {
+    SkDebugf("{{");
+    int index = 0;
+    do {
+        fPts[index].dump();
+        SkDebugf(", ");
+    } while (++index < 2);
+    fPts[index].dump();
+    SkDebugf("}}%s\n", comma ? comma : "");
 }
 
-void SkOpSpanBase::dump() const {
-    this->dumpAll();
-    SkDebugf("\n");
+void SkIntersectionHelper::dump() const {
+    SkDPoint::Dump(pts()[0]);
+    SkDPoint::Dump(pts()[1]);
+    if (verb() >= SkPath::kQuad_Verb) {
+        SkDPoint::Dump(pts()[2]);
+    }
+    if (verb() >= SkPath::kCubic_Verb) {
+        SkDPoint::Dump(pts()[3]);
+    }
 }
 
-void SkOpSpanBase::dumpAll() const {
-    SkDebugf("%.*s", contour()->debugIndent(), "        ");
-    SkDebugf("seg=%d span=%d", this->segment()->debugID(), this->debugID());
-    this->dumpBase();
-    SkDebugf("\n");
-    this->fPtT.dumpAll();
+const SkTDArray<SkOpSpan>& SkOpSegment::debugSpans() const {
+    return fTs;
 }
 
-void SkOpSpanBase::dumpBase() const {
-    if (this->fAligned) {
-        SkDebugf(" aligned");
-    }
-    if (this->fChased) {
-        SkDebugf(" chased");
-    }
-    if (!this->final()) {
-        this->upCast()->dumpSpan();
-    }
-    const SkOpSpanBase* coin = this->coinEnd();
-    if (this != coin) {
-        SkDebugf(" coinEnd seg/span=%d/%d", coin->segment()->debugID(), coin->debugID());
-    } else if (this->final() || !this->upCast()->isCoincident()) {
-        const SkOpPtT* oPt = this->ptT()->next();
-        SkDebugf(" seg/span=%d/%d", oPt->segment()->debugID(), oPt->span()->debugID());
+void SkOpSegment::dumpAngles() const {
+    SkDebugf("((SkOpSegment*) 0x%p) [%d]\n", this, debugID());
+    const SkOpAngle* fromAngle = NULL;
+    const SkOpAngle* toAngle = NULL;
+    for (int index = 0; index < count(); ++index) {
+        const SkOpAngle* fAngle = fTs[index].fFromAngle;
+        const SkOpAngle* tAngle = fTs[index].fToAngle;
+        if (fromAngle == fAngle && toAngle == tAngle) {
+            continue;
+        }
+        if (fAngle) {
+            SkDebugf("  [%d] from=%d ", index, fAngle->debugID());
+            fAngle->dumpTo(this, tAngle);
+        }
+        if (tAngle) {
+            SkDebugf("  [%d] to=%d   ", index, tAngle->debugID());
+            tAngle->dumpTo(this, fAngle);
+        }
+        fromAngle = fAngle;
+        toAngle = tAngle;
     }
 }
 
-void SkOpSpanBase::dumpCoin() const {
-    const SkOpSpan* span = this->upCastable();
-    if (!span) {
+void SkOpSegment::dumpContour(int firstID, int lastID) const {
+    if (debugID() < 0) {
         return;
     }
-    if (!span->isCoincident()) {
-        return;
+    const SkOpSegment* test = this - (debugID() - 1);
+    test += (firstID - 1);
+    const SkOpSegment* last = test + (lastID - firstID);
+    while (test <= last) {
+        test->dumpSpans();
+        ++test;
     }
-    span->dumpCoin();
 }
 
-void SkOpSpan::dumpCoin() const {
-    const SkOpSpan* coincident = fCoincident;
-    bool ok = debugCoinLoopCheck();
-    this->dump();
-    int loop = 0;
+void SkOpSegment::dumpPts() const {
+    int last = SkPathOpsVerbToPoints(fVerb);
+    SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
+    int index = 0;
     do {
-        coincident->dump();
-        if (!ok && ++loop > 10) {
-            SkDebugf("*** abort loop ***\n");
-            break;
+        SkDPoint::Dump(fPts[index]);
+        SkDebugf(", ");
+    } while (++index < last);
+    SkDPoint::Dump(fPts[index]);
+    SkDebugf("}}\n");
+}
+
+void SkOpSegment::dumpHexPts() const {
+    int last = SkPathOpsVerbToPoints(fVerb);
+    SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
+    int index = 0;
+    do {
+        SkDPoint::DumpHex(fPts[index]);
+        SkDebugf(", ");
+    } while (++index < last);
+    SkDPoint::DumpHex(fPts[index]);
+    SkDebugf("}}\n");
+}
+
+void SkOpSegment::dumpDPts() const {
+    int count = SkPathOpsVerbToPoints(fVerb);
+    SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
+    int index = 0;
+    do {
+        SkDPoint dPt = {fPts[index].fX, fPts[index].fY};
+        dPt.dump();
+        if (index != count) {
+            SkDebugf(", ");
         }
-    } while ((coincident = coincident->fCoincident) != this);
+    } while (++index <= count);
+    SkDebugf("}}\n");
 }
 
-bool SkOpSpan::dumpSpan() const {
-    SkOpSpan* coin = fCoincident;
-    if (this != coin) {
-        SkDebugf(" coinStart seg/span=%d/%d", coin->segment()->debugID(), coin->debugID());
+void SkOpSegment::dumpSpans() const {
+    int count = this->count();
+    SkDebugf("((SkOpSegment*) 0x%p) [%d]\n", this, debugID());
+    for (int index = 0; index < count; ++index) {
+        const SkOpSpan& span = this->span(index);
+        SkDebugf("  [%d] ", index);
+        span.dumpOne();
     }
-    SkDebugf(" windVal=%d", this->windValue());
-    SkDebugf(" windSum=");
-    SkPathOpsDebug::WindingPrintf(this->windSum());
-    if (this->oppValue() != 0 || this->oppSum() != SK_MinS32) {
-        SkDebugf(" oppVal=%d", this->oppValue());
-        SkDebugf(" oppSum=");
-        SkPathOpsDebug::WindingPrintf(this->oppSum());
+}
+
+void SkPathOpsDebug::DumpCoincidence(const SkTArray<SkOpContour, true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dumpCoincidences();
     }
-    if (this->done()) {
-        SkDebugf(" done");
+}
+
+void SkPathOpsDebug::DumpCoincidence(const SkTArray<SkOpContour* , true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dumpCoincidences();
     }
-    return this != coin;
 }
 
-const SkOpAngle* SkOpSegment::debugAngle(int id) const {
-    return this->contour()->debugAngle(id);
+void SkPathOpsDebug::DumpContours(const SkTArray<SkOpContour, true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dump();
+    }
 }
 
-SkOpContour* SkOpSegment::debugContour(int id) {
-    return this->contour()->debugContour(id);
+void SkPathOpsDebug::DumpContours(const SkTArray<SkOpContour* , true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dump();
+    }
 }
 
-const SkOpPtT* SkOpSegment::debugPtT(int id) const {
-    return this->contour()->debugPtT(id);
+void SkPathOpsDebug::DumpContourAngles(const SkTArray<SkOpContour, true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dumpAngles();
+    }
 }
 
-const SkOpSegment* SkOpSegment::debugSegment(int id) const {
-    return this->contour()->debugSegment(id);
+void SkPathOpsDebug::DumpContourAngles(const SkTArray<SkOpContour* , true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dumpAngles();
+    }
 }
 
-const SkOpSpanBase* SkOpSegment::debugSpan(int id) const {
-    return this->contour()->debugSpan(id);
+void SkPathOpsDebug::DumpContourPts(const SkTArray<SkOpContour, true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dumpPts();
+    }
 }
 
-void SkOpSegment::dump() const {
-    SkDebugf("%.*s", contour()->debugIndent(), "        ");
-    this->dumpPts();
-    const SkOpSpanBase* span = &fHead;
-    contour()->indentDump();
-    do {
-        SkDebugf("%.*s span=%d ", contour()->debugIndent(), "        ", span->debugID());
-        span->ptT()->dumpBase();
-        span->dumpBase();
-        SkDebugf("\n");
-    } while (!span->final() && (span = span->upCast()->next()));
-    contour()->outdentDump();
+void SkPathOpsDebug::DumpContourPts(const SkTArray<SkOpContour* , true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dumpPts();
+    }
 }
 
-void SkOpSegment::dumpAll() const {
-    SkDebugf("%.*s", contour()->debugIndent(), "        ");
-    this->dumpPts();
-    const SkOpSpanBase* span = &fHead;
-    contour()->indentDump();
-    do {
-        span->dumpAll();
-    } while (!span->final() && (span = span->upCast()->next()));
-    contour()->outdentDump();
+void SkPathOpsDebug::DumpContourPt(const SkTArray<SkOpContour, true>& contours, int segmentID) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dumpPt(segmentID);
+    }
 }
 
-void SkOpSegment::dumpAngles() const {
-    SkDebugf("seg=%d\n", debugID());
-    const SkOpSpanBase* span = &fHead;
-    do {
-        const SkOpAngle* fAngle = span->fromAngle();
-        const SkOpAngle* tAngle = span->final() ? NULL : span->upCast()->toAngle();
-        if (fAngle) {
-            SkDebugf("  span=%d from=%d ", span->debugID(), fAngle->debugID());
-            fAngle->dumpTo(this, tAngle);
-        }
-        if (tAngle) {
-            SkDebugf("  span=%d to=%d   ", span->debugID(), tAngle->debugID());
-            tAngle->dumpTo(this, fAngle);
-        }
-    } while (!span->final() && (span = span->upCast()->next()));
+void SkPathOpsDebug::DumpContourPt(const SkTArray<SkOpContour* , true>& contours, int segmentID) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dumpPt(segmentID);
+    }
 }
 
-void SkOpSegment::dumpCoin() const {
-    const SkOpSpan* span = &fHead;
-    do {
-        span->dumpCoin();
-    } while ((span = span->next()->upCastable()));
+void SkPathOpsDebug::DumpContourSpans(const SkTArray<SkOpContour, true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dumpSpans();
+    }
 }
 
-void SkOpSegment::dumpPts() const {
-    int last = SkPathOpsVerbToPoints(fVerb);
-    SkDebugf("seg=%d {{", this->debugID());
-    int index = 0;
-    do {
-        SkDPoint::Dump(fPts[index]);
-        SkDebugf(", ");
-    } while (++index < last);
-    SkDPoint::Dump(fPts[index]);
-    SkDebugf("}}\n");
+void SkPathOpsDebug::DumpContourSpans(const SkTArray<SkOpContour* , true>& contours) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dumpSpans();
+    }
 }
 
-void SkCoincidentSpans::dump() const {
-    SkDebugf("- seg=%d span=%d ptT=%d ", fCoinPtTStart->segment()->debugID(),
-        fCoinPtTStart->span()->debugID(), fCoinPtTStart->debugID());
-    fCoinPtTStart->dumpBase();
-    SkDebugf(" span=%d ptT=%d ", fCoinPtTEnd->span()->debugID(), fCoinPtTEnd->debugID());
-    fCoinPtTEnd->dumpBase();
-    if (fCoinPtTStart->segment()->operand()) {
-        SkDebugf(" operand");
+void SkPathOpsDebug::DumpContourSpan(const SkTArray<SkOpContour, true>& contours, int segmentID) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index].dumpSpan(segmentID);
     }
-    if (fCoinPtTStart->segment()->isXor()) {
-        SkDebugf(" xor");
+}
+
+void SkPathOpsDebug::DumpContourSpan(const SkTArray<SkOpContour* , true>& contours, int segmentID) {
+    int count = contours.count();
+    for (int index = 0; index < count; ++index) {
+        contours[index]->dumpSpan(segmentID);
     }
-    SkDebugf("\n");
-    SkDebugf("+ seg=%d span=%d ptT=%d ", fOppPtTStart->segment()->debugID(),
-        fOppPtTStart->span()->debugID(), fOppPtTStart->debugID());
-    fOppPtTStart->dumpBase();
-    SkDebugf(" span=%d ptT=%d ", fOppPtTEnd->span()->debugID(), fOppPtTEnd->debugID());
-    fOppPtTEnd->dumpBase();
-    if (fOppPtTStart->segment()->operand()) {
-        SkDebugf(" operand");
+}
+
+void SkPathOpsDebug::DumpSpans(const SkTDArray<SkOpSpan *>& spans) {
+    int count = spans.count();
+    for (int index = 0; index < count; ++index) {
+        const SkOpSpan* span = spans[index];
+        const SkOpSpan& oSpan = span->fOther->span(span->fOtherIndex);
+        const SkOpSegment* segment = oSpan.fOther;
+        SkDebugf("((SkOpSegment*) 0x%p) [%d] ", segment, segment->debugID());
+        SkDebugf("spanIndex:%d ", oSpan.fOtherIndex);
+        span->dumpOne();
+    }
+}
+
+// this does not require that other T index is initialized or correct
+const SkOpSegment* SkOpSpan::debugToSegment(ptrdiff_t* spanIndex) const {
+    if (!fOther) {
+        return NULL;
+    }
+    int oppCount = fOther->count();
+    for (int index = 0; index < oppCount; ++index) {
+        const SkOpSpan& otherSpan = fOther->span(index);
+        double otherTestT = otherSpan.fT;
+        if (otherTestT < fOtherT) {
+            continue;
+        }
+        SkASSERT(otherTestT == fOtherT);
+        const SkOpSegment* candidate = otherSpan.fOther;
+        const SkOpSpan* first = candidate->debugSpans().begin();
+        const SkOpSpan* last = candidate->debugSpans().end() - 1;
+        if (first <= this && this <= last) {
+            if (spanIndex) {
+                *spanIndex = this - first;
+            }
+            return candidate;
+        }
     }
-    if (fOppPtTStart->segment()->isXor()) {
-        SkDebugf(" xor");
+    SkASSERT(0);
+    return NULL;
+}
+
+void SkOpSpan::dumpOne() const {
+    SkDebugf("t=");
+    DebugDumpDouble(fT);
+    SkDebugf(" pt=");
+    SkDPoint::Dump(fPt);
+    if (fOther) {
+        SkDebugf(" other.fID=%d", fOther->debugID());
+        SkDebugf(" [%d] otherT=", fOtherIndex);
+        DebugDumpDouble(fOtherT);
+    } else {
+        SkDebugf(" other.fID=? [?] otherT=?");
+    }
+    if (fWindSum != SK_MinS32) {
+        SkDebugf(" windSum=%d", fWindSum);
+    }
+    if (fOppSum != SK_MinS32 && (SkPathOpsDebug::ValidWind(fOppSum) || fOppValue != 0)) {
+        SkDebugf(" oppSum=%d", fOppSum);
+    }
+    SkDebugf(" windValue=%d", fWindValue);
+    if (SkPathOpsDebug::ValidWind(fOppSum) || fOppValue != 0) {
+        SkDebugf(" oppValue=%d", fOppValue);
+    }
+    if (fFromAngle && fFromAngle->debugID()) {
+        SkDebugf(" from=%d", fFromAngle->debugID());
+    }
+    if (fToAngle && fToAngle->debugID()) {
+        SkDebugf(" to=%d", fToAngle->debugID());
+    }
+    if (fChased) {
+        SkDebugf(" chased");
+    }
+    if (fCoincident) {
+        SkDebugf(" coincident");
+    }
+    if (fDone) {
+        SkDebugf(" done");
+    }
+    if (fLoop) {
+        SkDebugf(" loop");
+    }
+    if (fMultiple) {
+        SkDebugf(" multiple");
+    }
+    if (fNear) {
+        SkDebugf(" near");
+    }
+    if (fSmall) {
+        SkDebugf(" small");
+    }
+    if (fTiny) {
+        SkDebugf(" tiny");
     }
     SkDebugf("\n");
 }
 
-void SkOpCoincidence::dump() const {
-    SkCoincidentSpans* span = fHead;
-    while (span) {
-        span->dump();
-        span = span->fNext;
+void SkOpSpan::dump() const {
+    ptrdiff_t spanIndex;
+    const SkOpSegment* segment = debugToSegment(&spanIndex);
+    if (segment) {
+        SkDebugf("((SkOpSegment*) 0x%p) [%d]\n", segment, segment->debugID());
+        SkDebugf("  [%d] ", spanIndex);
+    } else {
+        SkDebugf("((SkOpSegment*) ?) [?]\n");
+        SkDebugf("  [?] ");
     }
+    dumpOne();
 }
 
-void SkOpContour::dump() {
-    SkDebugf("contour=%d count=%d\n", this->debugID(), fCount);
-    if (!fCount) {
-        return;
-    }
-    const SkOpSegment* segment = &fHead;
-    PATH_OPS_DEBUG_CODE(fIndent = 0);
-    indentDump();
-    do {
-        segment->dump();
-    } while ((segment = segment->next()));
-    outdentDump();
+void Dump(const SkTArray<class SkOpContour, true>& contours) {
+    SkPathOpsDebug::DumpContours(contours);
 }
 
-void SkOpContour::dumpAll() {
-    SkDebugf("contour=%d count=%d\n", this->debugID(), fCount);
-    if (!fCount) {
-        return;
-    }
-    const SkOpSegment* segment = &fHead;
-    PATH_OPS_DEBUG_CODE(fIndent = 0);
-    indentDump();
-    do {
-        segment->dumpAll();
-    } while ((segment = segment->next()));
-    outdentDump();
+void Dump(const SkTArray<class SkOpContour* , true>& contours) {
+    SkPathOpsDebug::DumpContours(contours);
 }
 
+void Dump(const SkTArray<class SkOpContour, true>* contours) {
+    SkPathOpsDebug::DumpContours(*contours);
+}
 
-void SkOpContour::dumpAngles() const {
-    SkDebugf("contour=%d\n", this->debugID());
-    const SkOpSegment* segment = &fHead;
-    do {
-        SkDebugf("  seg=%d ", segment->debugID());
-        segment->dumpAngles();
-    } while ((segment = segment->next()));
+void Dump(const SkTArray<class SkOpContour* , true>* contours) {
+    SkPathOpsDebug::DumpContours(*contours);
 }
 
-void SkOpContour::dumpPt(int index) const {
-    const SkOpSegment* segment = &fHead;
-    do {
-        if (segment->debugID() == index) {
-            segment->dumpPts();
-        }
-    } while ((segment = segment->next()));
+void Dump(const SkTDArray<SkOpSpan *>& chase) {
+    SkPathOpsDebug::DumpSpans(chase);
 }
 
-void SkOpContour::dumpPts() const {
-    SkDebugf("contour=%d\n", this->debugID());
-    const SkOpSegment* segment = &fHead;
-    do {
-        SkDebugf("  seg=%d ", segment->debugID());
-        segment->dumpPts();
-    } while ((segment = segment->next()));
+void Dump(const SkTDArray<SkOpSpan *>* chase) {
+    SkPathOpsDebug::DumpSpans(*chase);
 }
 
-void SkOpContour::dumpPtsX() const {
-    if (!this->fCount) {
-        SkDebugf("<empty>\n");
-        return;
-    }
-    const SkOpSegment* segment = &fHead;
-    do {
-        segment->dumpPts();
-    } while ((segment = segment->next()));
+void DumpAngles(const SkTArray<class SkOpContour, true>& contours) {
+    SkPathOpsDebug::DumpContourAngles(contours);
 }
 
-void SkOpContour::dumpSegment(int index) const {
-    debugSegment(index)->dump();
+void DumpAngles(const SkTArray<class SkOpContour* , true>& contours) {
+    SkPathOpsDebug::DumpContourAngles(contours);
 }
 
-void SkOpContour::dumpSegments(SkPathOp op) const {
-    bool firstOp = false;
-    const SkOpContour* c = this;
-    do {
-        if (!firstOp && c->operand()) {
-#if DEBUG_ACTIVE_OP
-            SkDebugf("op %s\n", SkPathOpsDebug::kPathOpStr[op]);
-#endif
-            firstOp = true;
-        }
-        c->dumpPtsX();
-    } while ((c = c->next()));
+void DumpAngles(const SkTArray<class SkOpContour, true>* contours) {
+    SkPathOpsDebug::DumpContourAngles(*contours);
 }
 
-void SkOpContour::dumpSpan(int index) const {
-    debugSpan(index)->dump();
+void DumpAngles(const SkTArray<class SkOpContour* , true>* contours) {
+    SkPathOpsDebug::DumpContourAngles(*contours);
 }
 
-void SkOpContour::dumpSpans() const {
-    SkDebugf("contour=%d\n", this->debugID());
-    const SkOpSegment* segment = &fHead;
-    do {
-        SkDebugf("  seg=%d ", segment->debugID());
-        segment->dump();
-    } while ((segment = segment->next()));
+void DumpCoin(const SkTArray<class SkOpContour, true>& contours) {
+    SkPathOpsDebug::DumpCoincidence(contours);
 }
 
-#ifdef SK_DEBUG
-const SkOpAngle* SkOpGlobalState::debugAngle(int id) const {
-    const SkOpContour* contour = fHead;
-    do {
-        const SkOpSegment* segment = contour->first();
-        while (segment) {
-            const SkOpSpan* span = segment->head();
-            do {
-                SkOpAngle* angle = span->fromAngle();
-                if (angle && angle->debugID() == id) {
-                    return angle;
-                }
-                angle = span->toAngle();
-                if (angle && angle->debugID() == id) {
-                    return angle;
-                }
-            } while ((span = span->next()->upCastable()));
-            const SkOpSpanBase* tail = segment->tail();
-            SkOpAngle* angle = tail->fromAngle();
-            if (angle && angle->debugID() == id) {
-                return angle;
-            }
-            segment = segment->next();
-        }
-    } while ((contour = contour->next()));
-    return NULL;
+void DumpCoin(const SkTArray<class SkOpContour* , true>& contours) {
+    SkPathOpsDebug::DumpCoincidence(contours);
 }
 
-SkOpContour* SkOpGlobalState::debugContour(int id) {
-    SkOpContour* contour = fHead;
-    do {
-        if (contour->debugID() == id) {
-            return contour;
-        }
-    } while ((contour = contour->next()));
-    return NULL;
+void DumpCoin(const SkTArray<class SkOpContour, true>* contours) {
+    SkPathOpsDebug::DumpCoincidence(*contours);
 }
 
-const SkOpPtT* SkOpGlobalState::debugPtT(int id) const {
-    const SkOpContour* contour = fHead;
-    do {
-        const SkOpSegment* segment = contour->first();
-        while (segment) {
-            const SkOpSpan* span = segment->head();
-            do {
-                const SkOpPtT* ptT = span->ptT();
-                if (ptT->debugMatchID(id)) {
-                    return ptT;
-                }
-            } while ((span = span->next()->upCastable()));
-            const SkOpSpanBase* tail = segment->tail();
-            const SkOpPtT* ptT = tail->ptT();
-            if (ptT->debugMatchID(id)) {
-                return ptT;
-            }
-            segment = segment->next();
-        }
-    } while ((contour = contour->next()));
-    return NULL;
+void DumpCoin(const SkTArray<class SkOpContour* , true>* contours) {
+    SkPathOpsDebug::DumpCoincidence(*contours);
 }
 
-const SkOpSegment* SkOpGlobalState::debugSegment(int id) const {
-    const SkOpContour* contour = fHead;
-    do {
-        const SkOpSegment* segment = contour->first();
-        while (segment) {
-            if (segment->debugID() == id) {
-                return segment;
-            }
-            segment = segment->next();
-        }
-    } while ((contour = contour->next()));
-    return NULL;
+void DumpSpans(const SkTArray<class SkOpContour, true>& contours) {
+    SkPathOpsDebug::DumpContourSpans(contours);
 }
 
-const SkOpSpanBase* SkOpGlobalState::debugSpan(int id) const {
-    const SkOpContour* contour = fHead;
-    do {
-        const SkOpSegment* segment = contour->first();
-        while (segment) {
-            const SkOpSpan* span = segment->head();
-            do {
-                if (span->debugID() == id) {
-                    return span;
-                }
-            } while ((span = span->next()->upCastable()));
-            const SkOpSpanBase* tail = segment->tail();
-            if (tail->debugID() == id) {
-                return tail;
-            }
-            segment = segment->next();
-        }
-    } while ((contour = contour->next()));
-    return NULL;
+void DumpSpans(const SkTArray<class SkOpContour* , true>& contours) {
+    SkPathOpsDebug::DumpContourSpans(contours);
 }
-#endif
 
-const SkOpAngle* DebugAngle(const SkTArray<SkOpContour*, true>* contours, int id) {
-    return (*contours)[0]->debugAngle(id);
+void DumpSpans(const SkTArray<class SkOpContour, true>* contours) {
+    SkPathOpsDebug::DumpContourSpans(*contours);
 }
 
-SkOpContour* DumpContour(const SkTArray<SkOpContour*, true>* contours, int id) {
-    return (*contours)[0]->debugContour(id);
+void DumpSpans(const SkTArray<class SkOpContour* , true>* contours) {
+    SkPathOpsDebug::DumpContourSpans(*contours);
 }
 
-const SkOpPtT* DebugPtT(const SkTArray<SkOpContour*, true>* contours, int id) {
-    return (*contours)[0]->debugPtT(id);
+void DumpSpan(const SkTArray<class SkOpContour, true>& contours, int segmentID) {
+    SkPathOpsDebug::DumpContourSpan(contours, segmentID);
 }
 
-const SkOpSegment* DebugSegment(const SkTArray<SkOpContour*, true>* contours, int id) {
-    return (*contours)[0]->debugSegment(id);
+void DumpSpan(const SkTArray<class SkOpContour* , true>& contours, int segmentID) {
+    SkPathOpsDebug::DumpContourSpan(contours, segmentID);
 }
 
-const SkOpSpanBase* DebugSpan(const SkTArray<SkOpContour*, true>* contours, int id) {
-    return (*contours)[0]->debugSpan(id);
+void DumpSpan(const SkTArray<class SkOpContour, true>* contours, int segmentID) {
+    SkPathOpsDebug::DumpContourSpan(*contours, segmentID);
 }
 
-void Dump(SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContours(contours);
+void DumpSpan(const SkTArray<class SkOpContour* , true>* contours, int segmentID) {
+    SkPathOpsDebug::DumpContourSpan(*contours, segmentID);
 }
 
-void DumpAll(SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursAll(contours);
+void DumpPts(const SkTArray<class SkOpContour, true>& contours) {
+    SkPathOpsDebug::DumpContourPts(contours);
 }
 
-void DumpAngles(const SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursAngles(contours);
+void DumpPts(const SkTArray<class SkOpContour* , true>& contours) {
+    SkPathOpsDebug::DumpContourPts(contours);
 }
 
-void DumpSegment(const SkTDArray<SkOpContour* >* contours, int segmentID) {
-    SkPathOpsDebug::DumpContoursSegment(contours, segmentID);
+void DumpPts(const SkTArray<class SkOpContour, true>* contours) {
+    SkPathOpsDebug::DumpContourPts(*contours);
 }
 
-void DumpSpan(const SkTDArray<SkOpContour* >* contours, int spanID) {
-    SkPathOpsDebug::DumpContoursSpan(contours, spanID);
+void DumpPts(const SkTArray<class SkOpContour* , true>* contours) {
+    SkPathOpsDebug::DumpContourPts(*contours);
 }
 
-void DumpSpans(const SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursSpans(contours);
+void DumpPt(const SkTArray<class SkOpContour, true>& contours, int segmentID) {
+    SkPathOpsDebug::DumpContourPt(contours, segmentID);
 }
 
-void DumpPt(const SkTDArray<SkOpContour* >* contours, int segmentID) {
-    SkPathOpsDebug::DumpContoursPt(contours, segmentID);
+void DumpPt(const SkTArray<class SkOpContour* , true>& contours, int segmentID) {
+    SkPathOpsDebug::DumpContourPt(contours, segmentID);
 }
 
-void DumpPts(const SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursPts(contours);
+void DumpPt(const SkTArray<class SkOpContour, true>* contours, int segmentID) {
+    SkPathOpsDebug::DumpContourPt(*contours, segmentID);
 }
 
-#if DEBUG_T_SECT_DUMP > 1
-int gDumpTSectNum;
-#endif
+void DumpPt(const SkTArray<class SkOpContour* , true>* contours, int segmentID) {
+    SkPathOpsDebug::DumpContourPt(*contours, segmentID);
+}
+
+static void dumpTestCase(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
+    SkDebugf("<div id=\"quad%d\">\n", testNo);
+    quad1.dumpComma(",");
+    quad2.dump();
+    SkDebugf("</div>\n\n");
+}
+
+static void dumpTestTrailer() {
+    SkDebugf("</div>\n\n<script type=\"text/javascript\">\n\n");
+    SkDebugf("    var testDivs = [\n");
+}
+
+static void dumpTestList(int testNo, double min) {
+    SkDebugf("        quad%d,", testNo);
+    if (min > 0) {
+        SkDebugf("  // %1.9g", min);
+    }
+    SkDebugf("\n");
+}
+
+void DumpQ(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
+    SkDebugf("\n");
+    dumpTestCase(quad1, quad2, testNo);
+    dumpTestTrailer();
+    dumpTestList(testNo, 0);
+    SkDebugf("\n");
+}
+
+void DumpT(const SkDQuad& quad, double t) {
+    SkDLine line = {{quad.ptAtT(t), quad[0]}};
+    line.dump();
+}