turn off debugging printfs

src/pathops/SkOpSegment.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkIntersections.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
@@ skipping 1064 matching lines @@
     if (!span->fWindValue && !span->fOppValue) {
         span->fDone = true;
         ++fDoneSpans;
         return true;
     }
     return false;
 }
 
 // look to see if the curve end intersects an intermediary that intersects the other
 void SkOpSegment::checkEnds() {
-#if 1
-    return;  // FIXME: suspect we will need the code below to make intersections consistent
-#else
+    debugValidate();
     SkTDArray<SkOpSpan> missingSpans;
     int count = fTs.count();
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = fTs[index];
         const SkOpSegment* other = span.fOther;
         const SkOpSpan* otherSpan = &other->fTs[span.fOtherIndex];
         double otherT = otherSpan->fT;
         if (otherT != 0 && otherT != 1) {
             continue;
         }
@@ skipping 45 matching lines @@
             SkOpSpan* missing = missingSpans.append();
             missing->fT = t;
             missing->fOther = match;
             missing->fOtherT = matchT;
             missing->fPt = peekSpan.fPt;
         }
 nextPeeker:
         ;
     }
     int missingCount = missingSpans.count();
+    if (missingCount == 0) {
+        return;
+    }
+    debugValidate();
     for (int index = 0; index < missingCount; ++index)  {
         const SkOpSpan& missing = missingSpans[index];
         addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt);
     }
-    if (missingCount > 0) {
-        fixOtherTIndex();
+    fixOtherTIndex();
+    for (int index = 0; index < missingCount; ++index)  {
+        const SkOpSpan& missing = missingSpans[index];
+        missing.fOther->fixOtherTIndex();
     }
-#endif
+    debugValidate();
 }
 
 bool SkOpSegment::equalPoints(int greaterTIndex, int lesserTIndex) {
     SkASSERT(greaterTIndex >= lesserTIndex);
     double greaterT = fTs[greaterTIndex].fT;
     double lesserT = fTs[lesserTIndex].fT;
     if (greaterT == lesserT) {
         return true;
     }
     if (!approximately_negative(greaterT - lesserT)) {
@@ skipping 614 matching lines @@
 // while the following fixes the indices up again, it isn't smart about
 // skipping segments whose indices are already correct
 // assuming we leave the code that wrote the index in the first place
 void SkOpSegment::fixOtherTIndex() {
     int iCount = fTs.count();
     for (int i = 0; i < iCount; ++i) {
         SkOpSpan& iSpan = fTs[i];
         double oT = iSpan.fOtherT;
         SkOpSegment* other = iSpan.fOther;
         int oCount = other->fTs.count();
+        SkDEBUGCODE(iSpan.fOtherIndex = -1);
         for (int o = 0; o < oCount; ++o) {
             SkOpSpan& oSpan = other->fTs[o];
             if (oT == oSpan.fT && this == oSpan.fOther && oSpan.fOtherT == iSpan.fT) {
                 iSpan.fOtherIndex = o;
+                oSpan.fOtherIndex = i;
                 break;
             }
         }
+        SkASSERT(iSpan.fOtherIndex >= 0);
     }
 }
 
 void SkOpSegment::init(const SkPoint pts[], SkPath::Verb verb, bool operand, bool evenOdd) {
     fDoneSpans = 0;
     fOperand = operand;
     fXor = evenOdd;
     fPts = pts;
     fVerb = verb;
 }
@@ skipping 936 matching lines @@
     }
     if (done()) {
         SkDebugf(" done");
     }
     SkDebugf("\n");
 }
 #endif
 
 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY
 void SkOpSegment::debugShowActiveSpans() const {
+    debugValidate();
     if (done()) {
         return;
     }
 #if DEBUG_ACTIVE_SPANS_SHORT_FORM
     int lastId = -1;
     double lastT = -1;
 #endif
     for (int i = 0; i < fTs.count(); ++i) {
-        SkASSERT(&fTs[i] == &fTs[i].fOther->fTs[fTs[i].fOtherIndex].fOther->
-                fTs[fTs[i].fOther->fTs[fTs[i].fOtherIndex].fOtherIndex]);
         if (fTs[i].fDone) {
             continue;
         }
         SkASSERT(i < fTs.count() - 1);
 #if DEBUG_ACTIVE_SPANS_SHORT_FORM
         if (lastId == fID && lastT == fTs[i].fT) {
             continue;
         }
         lastId = fID;
         lastT = fTs[i].fT;
@@ skipping 210 matching lines @@
         sum += fTs[i].fWindValue;
         slots[fTs[i].fOther->fID - 1] = as_digit(fTs[i].fWindValue);
         sum += fTs[i].fOppValue;
         slots[slotCount + fTs[i].fOther->fID - 1] = as_digit(fTs[i].fOppValue);
     }
     SkDebugf("%s id=%2d %.*s | %.*s\n", __FUNCTION__, fID, slotCount, slots.begin(), slotCount,
             slots.begin() + slotCount);
     return sum;
 }
 #endif
+
+void SkOpSegment::debugValidate() const {
+#if DEBUG_VALIDATE
+    int count = fTs.count();
+    SkASSERT(count >= 2);
+    SkASSERT(fTs[0].fT == 0);
+    SkASSERT(fTs[count - 1].fT == 1);
+    int done = 0;
+    double t = -1;
+    for (int i = 0; i < count; ++i) {
+        const SkOpSpan& span = fTs[i];
+        SkASSERT(t <= span.fT);
+        t = span.fT;
+        int otherIndex = span.fOtherIndex;
+        const SkOpSegment* other = span.fOther;
+        const SkOpSpan& otherSpan = other->fTs[otherIndex];
+        SkASSERT(otherSpan.fPt == span.fPt);
+        SkASSERT(otherSpan.fOtherT == t);
+        SkASSERT(&fTs[i] == &otherSpan.fOther->fTs[otherSpan.fOtherIndex]);
+        done += span.fDone;
+    }
+    SkASSERT(done == fDoneSpans);
+#endif
+}