add asserts to point<-->verb helpers

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 "SkPathOpsCurve.h"
 #include "SkTSort.h"
@@ skipping 95 matching lines @@
     int roots, rroots;
     bool flip = false;
     bool useThis;
     bool leftLessThanRight = fSide > 0;
     do {
         useThis = (len < rlen) ^ flip;
         const SkDCubic& part = useThis ? fCurvePart : rh.fCurvePart;
         SkPath::Verb partVerb = useThis ? fVerb : rh.fVerb;
         ray[0] = partVerb == SkPath::kCubic_Verb && part[0].approximatelyEqual(part[1]) ?
             part[2] : part[1];
-        ray[1].fX = (part[0].fX + part[partVerb].fX) / 2;
-        ray[1].fY = (part[0].fY + part[partVerb].fY) / 2;
+        ray[1].fX = (part[0].fX + part[SkPathOpsVerbToPoints(partVerb)].fX) / 2;
+        ray[1].fY = (part[0].fY + part[SkPathOpsVerbToPoints(partVerb)].fY) / 2;
         SkASSERT(ray[0] != ray[1]);
-        roots = (i.*CurveRay[fVerb])(fPts, ray);
-        rroots = (ri.*CurveRay[rh.fVerb])(rh.fPts, ray);
+        roots = (i.*CurveRay[SkPathOpsVerbToPoints(fVerb)])(fPts, ray);
+        rroots = (ri.*CurveRay[SkPathOpsVerbToPoints(rh.fVerb)])(rh.fPts, ray);
     } while ((roots == 0 || rroots == 0) && (flip ^= true));
     if (roots == 0 || rroots == 0) {
         // FIXME: we don't have a solution in this case. The interim solution
         // is to mark the edges as unsortable, exclude them from this and
         // future computations, and allow the returned path to be fragmented
         fUnsortable = true;
         rh.fUnsortable = true;
         return this < &rh;  // even with no solution, return a stable sort
     }
     SkASSERT(fSide != 0 && rh.fSide != 0);
@@ skipping 176 matching lines @@
     for (int index = fStart; index != fEnd; index += step) {
 #if 1
         const SkOpSpan& thisSpan = (*fSpans)[index];
         const SkOpSpan& nextSpan = (*fSpans)[index + step];
         if (thisSpan.fTiny || precisely_equal(thisSpan.fT, nextSpan.fT)) {
             continue;
         }
         fUnsortable = step > 0 ? thisSpan.fUnsortableStart : nextSpan.fUnsortableEnd;
 #if DEBUG_UNSORTABLE
         if (fUnsortable) {
-            SkPoint iPt = (*CurvePointAtT[fVerb])(fPts, thisSpan.fT);
-            SkPoint ePt = (*CurvePointAtT[fVerb])(fPts, nextSpan.fT);
+            SkPoint iPt = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, thisSpan.fT);
+            SkPoint ePt = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, nextSpan.fT);
             SkDebugf("%s unsortable [%d] (%1.9g,%1.9g) [%d] (%1.9g,%1.9g)\n", __FUNCTION__,
                     index, iPt.fX, iPt.fY, fEnd, ePt.fX, ePt.fY);
         }
 #endif
         return;
 #else
         if ((*fSpans)[index].fUnsortableStart) {
             fUnsortable = true;
             return;
         }
 #endif
     }
 #if 1
 #if DEBUG_UNSORTABLE
-    SkPoint iPt = (*CurvePointAtT[fVerb])(fPts, startT);
-    SkPoint ePt = (*CurvePointAtT[fVerb])(fPts, endT);
+    SkPoint iPt = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, startT);
+    SkPoint ePt = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, endT);
     SkDebugf("%s all tiny unsortable [%d] (%1.9g,%1.9g) [%d] (%1.9g,%1.9g)\n", __FUNCTION__,
         fStart, iPt.fX, iPt.fY, fEnd, ePt.fX, ePt.fY);
 #endif
     fUnsortable = true;
 #endif
 }