fix bugs found by computing flat clips in 800K skps

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 271 matching lines @@
 }
 
 // the original angle is too short to get meaningful sector information
 // lengthen it until it is long enough to be meaningful or leave it unset if lengthening it
 // would cause it to intersect one of the adjacent angles
 bool SkOpAngle::computeSector() {
     if (fComputedSector) {
         // FIXME: logically, this should return !fUnorderable, but doing so breaks testQuadratic51
         // -- but in general, this code may not work so this may be the least of problems
         // adding the bang fixes testQuads46x in release, however
-        return fUnorderable;
+        return !fUnorderable;
     }
     SkASSERT(fSegment->verb() != SkPath::kLine_Verb && small());
     fComputedSector = true;
     int step = fStart < fEnd ? 1 : -1;
     int limit = step > 0 ? fSegment->count() : -1;
     int checkEnd = fEnd;
     do {
 // advance end
         const SkOpSpan& span = fSegment->span(checkEnd);
         const SkOpSegment* other = span.fOther;
@@ skipping 12 matching lines @@
             goto recomputeSector;
         }
         checkEnd += step;
     } while (checkEnd != limit);
 recomputeSector:
     if (checkEnd == fEnd || checkEnd - step == fEnd) {
         fUnorderable = true;
         return false;
     }
     int saveEnd = fEnd;
-    fEnd = checkEnd - step;
+    fComputedEnd = fEnd = checkEnd - step;
     setSpans();
     setSector();
     fEnd = saveEnd;
     return !fUnorderable;
 }
 
 // returns -1 if overlaps   0 if no overlap cw    1 if no overlap ccw
 int SkOpAngle::convexHullOverlaps(const SkOpAngle& rh) const {
     const SkDVector* sweep = fSweep;
     const SkDVector* tweep = rh.fSweep;
@@ skipping 71 matching lines @@
     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);
 //      SkASSERT(i.used() >= 1);
-        if (i.used() <= 1) {
-            continue;
-        }
+//        if (i.used() <= 1) {
+//            continue;
+//        }
         double tStart = segment.t(index ? rh.fStart : fStart);
-        double tEnd = segment.t(index ? rh.fEnd : fEnd);
-        bool testAscends = index ? rh.fStart < rh.fEnd : fStart < fEnd;
+        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];
             if (!approximately_between_orderable(tStart, testT, tEnd)) {
                 continue;
             }
             if (approximately_equal_orderable(tStart, testT)) {
                 continue;
             }
             smallTs[index] = t = testAscends ? SkTMax(t, testT) : SkTMin(t, testT);
@@ skipping 439 matching lines @@
     do {
         SkOpAngle* next = last->fNext;
         if (next == this) {
             return last;
         }
         last = next;
     } while (true);
 }
 
 void SkOpAngle::set(const SkOpSegment* segment, int start, int end) {
-#if DEBUG_ANGLE
-    fID = 0;
-#endif
     fSegment = segment;
     fStart = start;
-    fEnd = end;
+    fComputedEnd = fEnd = end;
     fNext = NULL;
     fComputeSector = fComputedSector = false;
     fStop = false;
     setSpans();
     setSector();
 }
 
 void SkOpAngle::setCurveHullSweep() {
     fUnorderedSweep = false;
     fSweep[0] = fCurvePart[1] - fCurvePart[0];
@@ skipping 192 matching lines @@
         return true;
     }
     SkASSERT(s0dt0 != 0);
     double m = s0xt0 / s0dt0;
     double sDist = sweep[0].length() * m;
     double tDist = tweep[0].length() * m;
     bool useS = fabs(sDist) < fabs(tDist);
     double mFactor = fabs(useS ? distEndRatio(sDist) : rh.distEndRatio(tDist));
     return mFactor < 5000;  // empirically found limit
 }
+
+SkOpAngleSet::SkOpAngleSet() 
+    : fAngles(NULL)
+#if DEBUG_ANGLE
+    , fCount(0)
+#endif
+{
+}
+
+SkOpAngleSet::~SkOpAngleSet() {
+    SkDELETE(fAngles);
+}
+
+SkOpAngle& SkOpAngleSet::push_back() {
+    if (!fAngles) {
+        fAngles = SkNEW_ARGS(SkChunkAlloc, (2));
+    }
+    void* ptr = fAngles->allocThrow(sizeof(SkOpAngle));
+    SkOpAngle* angle = (SkOpAngle*) ptr;
+#if DEBUG_ANGLE
+    angle->setID(++fCount);
+#endif
+    return *angle;
+}
+
+void SkOpAngleSet::reset() {
+    if (fAngles) {
+        fAngles->reset();
+    }
+}