path ops work in progress

src/pathops/SkIntersections.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"
 
 int (SkIntersections::*CurveVertical[])(const SkPoint[], SkScalar, SkScalar, SkScalar, bool) = {
@@ skipping 27 matching lines @@
         }
 #endif
     }
     SkASSERT(count == count2);
     return count;
 }
 
 int SkIntersections::cubicRay(const SkPoint pts[4], const SkDLine& line) {
     SkDCubic cubic;
     cubic.set(pts);
+    fMax = 3;
     return intersectRay(cubic, line);
 }
 
 void SkIntersections::flip() {
     for (int index = 0; index < fUsed; ++index) {
         fT[1][index] = 1 - fT[1][index];
     }
 }
 
 int SkIntersections::insert(double one, double two, const SkDPoint& pt) {
@@ skipping 22 matching lines @@
         }
     #if ONE_OFF_DEBUG
         if (pt.roughlyEqual(fPt[index])) {
             SkDebugf("%s t=%1.9g pts roughly equal\n", __FUNCTION__, one);
         }
     #endif
         if (fT[0][index] > one) {
             break;
         }
     }
-    SkASSERT(fUsed < 9);
+    if (fUsed >= fMax) {
+        SkASSERT(0);  // FIXME : this error, if it is to be handled at runtime in release, must
+                      // be propagated all the way back down to the caller, and return failure.
+        fUsed = 0;
+        return 0;
+    }
     int remaining = fUsed - index;
     if (remaining > 0) {
         memmove(&fPt[index + 1], &fPt[index], sizeof(fPt[0]) * remaining);
         memmove(&fT[0][index + 1], &fT[0][index], sizeof(fT[0][0]) * remaining);
         memmove(&fT[1][index + 1], &fT[1][index], sizeof(fT[1][0]) * remaining);
         int clearMask = ~((1 << index) - 1);
         fIsCoincident[0] += fIsCoincident[0] & clearMask;
         fIsCoincident[1] += fIsCoincident[1] & clearMask;
         fIsNear += fIsNear & clearMask;
     }
@@ skipping 24 matching lines @@
         double val = fT[fSwap][index];
         val *= end - start;
         val += start;
         fT[fSwap][index] = val;
     }
 }
 
 int SkIntersections::quadRay(const SkPoint pts[3], const SkDLine& line) {
     SkDQuad quad;
     quad.set(pts);
+    fMax = 2;
     return intersectRay(quad, line);
 }
 
 void SkIntersections::quickRemoveOne(int index, int replace) {
     if (index < replace) {
         fT[0][index] = fT[0][replace];
     }
 }
 
 #if 0
@@ skipping 46 matching lines @@
     quad.set(a);
     return vertical(quad, top, bottom, x, flipped);
 }
 
 int SkIntersections::verticalCubic(const SkPoint a[4], SkScalar top, SkScalar bottom,
         SkScalar x, bool flipped) {
     SkDCubic cubic;
     cubic.set(a);
     return vertical(cubic, top, bottom, x, flipped);
 }