harden pathops for pathological test

src/pathops/SkOpAngle.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 "SkOpAngle.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsCurve.h"
@@ skipping 391 matching lines @@
     SkDLine rays[] = {{{fCurvePart[0], rh.fCurvePart[rPts]}},
             {{fCurvePart[0], fCurvePart[lPts]}}};
     if (rays[0][1] == rays[1][1]) {
         return checkParallel(rh);
     }
     double smallTs[2] = {-1, -1};
     bool limited[2] = {false, false};
     for (int index = 0; index < 2; ++index) {
         const SkOpSegment& segment = index ? *rh.fSegment : *fSegment;
         SkIntersections i;
-        (*CurveIntersectRay[index ? rPts : lPts])(segment.pts(), rays[index], &i);
+        int cPts = index ? rPts : lPts;
+        (*CurveIntersectRay[cPts])(segment.pts(), rays[index], &i);
+        // if the curve is a line, then the line and the ray intersect only at their crossing
+        if (cPts == 1) { // line
+            continue;
+        }
 //      SkASSERT(i.used() >= 1);
 //        if (i.used() <= 1) {
 //            continue;
 //        }
         double tStart = segment.t(index ? rh.fStart : fStart);
         double tEnd = segment.t(index ? rh.fComputedEnd : fComputedEnd);
         bool testAscends = index ? rh.fStart < rh.fComputedEnd : fStart < fComputedEnd;
         double t = testAscends ? 0 : 1;
         for (int idx2 = 0; idx2 < i.used(); ++idx2) {
             double testT = i[0][idx2];
@@ skipping 227 matching lines @@
             angle->insert(this);
         }
         return;
     }
     bool singleton = NULL == fNext;
     if (singleton) {
         fNext = this;
     }
     SkOpAngle* next = fNext;
     if (next->fNext == this) {
-        if (angle->overlap(*this)) {
+        if (angle->overlap(*this)) {  // angles are essentially coincident
             return;
         }
         if (singleton || angle->after(this)) {
             this->fNext = angle;
             angle->fNext = next;
         } else {
             next->fNext = angle;
             angle->fNext = this;
         }
         debugValidateNext();
@@ skipping 99 matching lines @@
         }
         working = working->fNext;
     } while (working != angle);
     do {
         SkOpAngle* next = working->fNext;
         working->fNext = NULL;
         insert(working);
         working = next;
     } while (working != angle);
     // it's likely that a pair of the angles are unorderable
-#if DEBUG_ANGLE
+#if 0 && DEBUG_ANGLE
     SkOpAngle* last = angle;
     working = angle->fNext;
     do {
         SkASSERT(last->fNext == working);
         last->fNext = working->fNext;
         SkASSERT(working->after(last));
         last->fNext = working;
         last = working;
         working = working->fNext;
     } while (last != angle);
@@ skipping 330 matching lines @@
     angle->setID(++fCount);
 #endif
     return *angle;
 }
 
 void SkOpAngleSet::reset() {
     if (fAngles) {
         fAngles->reset();
     }
 }