allow conic chop to fail

src/core/SkGeometry.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGeometry.h"
 #include "SkMatrix.h"
 #include "SkNx.h"
@@ skipping 957 matching lines @@
     dst[3] = SkScalarInterp(ab, bc, t);
     dst[6] = bc;
 }
 
 static void ratquad_mapTo3D(const SkPoint src[3], SkScalar w, SkP3D dst[]) {
     dst[0].set(src[0].fX * 1, src[0].fY * 1, 1);
     dst[1].set(src[1].fX * w, src[1].fY * w, w);
     dst[2].set(src[2].fX * 1, src[2].fY * 1, 1);
 }
 
-void SkConic::chopAt(SkScalar t, SkConic dst[2]) const {
+// return false if infinity or NaN is generated; caller must check
+bool SkConic::chopAt(SkScalar t, SkConic dst[2]) const {
     SkP3D tmp[3], tmp2[3];
 
     ratquad_mapTo3D(fPts, fW, tmp);
 
     p3d_interp(&tmp[0].fX, &tmp2[0].fX, t);
     p3d_interp(&tmp[0].fY, &tmp2[0].fY, t);
     p3d_interp(&tmp[0].fZ, &tmp2[0].fZ, t);
 
     dst[0].fPts[0] = fPts[0];
     tmp2[0].projectDown(&dst[0].fPts[1]);
     tmp2[1].projectDown(&dst[0].fPts[2]); dst[1].fPts[0] = dst[0].fPts[2];
     tmp2[2].projectDown(&dst[1].fPts[1]);
     dst[1].fPts[2] = fPts[2];
 
     // to put in "standard form", where w0 and w2 are both 1, we compute the
     // new w1 as sqrt(w1*w1/w0*w2)
     // or
     // w1 /= sqrt(w0*w2)
     //
     // However, in our case, we know that for dst[0]:
     //     w0 == 1, and for dst[1], w2 == 1
     //
     SkScalar root = SkScalarSqrt(tmp2[1].fZ);
     dst[0].fW = tmp2[0].fZ / root;
     dst[1].fW = tmp2[2].fZ / root;
+    SkASSERT(sizeof(dst[0]) == sizeof(SkScalar) * 7);
+    SkASSERT(0 == offsetof(SkConic, fPts[0].fX));
+    return SkScalarsAreFinite(&dst[0].fPts[0].fX, 7 * 2);
 }
 
 void SkConic::chopAt(SkScalar t1, SkScalar t2, SkConic* dst) const {
     if (0 == t1 || 1 == t2) {
         if (0 == t1 && 1 == t2) {
             *dst = *this;
+            return;
         } else {
             SkConic pair[2];
-            this->chopAt(t1 ? t1 : t2, pair);
-            *dst = pair[SkToBool(t1)];
+            if (this->chopAt(t1 ? t1 : t2, pair)) {
+                *dst = pair[SkToBool(t1)];
+                return;
+            }
         }
-        return;
     }
     SkConicCoeff coeff(*this);
     Sk2s tt1(t1);
     Sk2s aXY = coeff.fNumer.eval(tt1);
     Sk2s aZZ = coeff.fDenom.eval(tt1);
     Sk2s midTT((t1 + t2) / 2);
     Sk2s dXY = coeff.fNumer.eval(midTT);
     Sk2s dZZ = coeff.fDenom.eval(midTT);
     Sk2s tt2(t2);
     Sk2s cXY = coeff.fNumer.eval(tt2);
@@ skipping 210 matching lines @@
     return conic_find_extrema(&fPts[0].fX, fW, t);
 }
 
 bool SkConic::findYExtrema(SkScalar* t) const {
     return conic_find_extrema(&fPts[0].fY, fW, t);
 }
 
 bool SkConic::chopAtXExtrema(SkConic dst[2]) const {
     SkScalar t;
     if (this->findXExtrema(&t)) {
-        this->chopAt(t, dst);
+        if (!this->chopAt(t, dst)) {
+            // if chop can't return finite values, don't chop
+            return false;
+        }
         // now clean-up the middle, since we know t was meant to be at
         // an X-extrema
         SkScalar value = dst[0].fPts[2].fX;
         dst[0].fPts[1].fX = value;
         dst[1].fPts[0].fX = value;
         dst[1].fPts[1].fX = value;
         return true;
     }
     return false;
 }
 
 bool SkConic::chopAtYExtrema(SkConic dst[2]) const {
     SkScalar t;
     if (this->findYExtrema(&t)) {
-        this->chopAt(t, dst);
+        if (!this->chopAt(t, dst)) {
+            // if chop can't return finite values, don't chop
+            return false;
+        }
         // now clean-up the middle, since we know t was meant to be at
         // an Y-extrema
         SkScalar value = dst[0].fPts[2].fY;
         dst[0].fPts[1].fY = value;
         dst[1].fPts[0].fY = value;
         dst[1].fPts[1].fY = value;
         return true;
     }
     return false;
 }
@@ skipping 125 matching lines @@
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
     }
     if (userMatrix) {
         matrix.postConcat(*userMatrix);
     }
     for (int i = 0; i < conicCount; ++i) {
         matrix.mapPoints(dst[i].fPts, 3);
     }
     return conicCount;
 }