Loosen check for zero vectors in GrPathUtils::convert_noninflect_cubic_to_quads

src/gpu/GrPathUtils.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrPathUtils.h"
 
 #include "GrTypes.h"
@@ skipping 115 matching lines @@
 uint32_t GrPathUtils::generateCubicPoints(const SkPoint& p0,
                                           const SkPoint& p1,
                                           const SkPoint& p2,
                                           const SkPoint& p3,
                                           SkScalar tolSqd,
                                           SkPoint** points,
                                           uint32_t pointsLeft) {
     if (pointsLeft < 2 ||
         (p1.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd &&
          p2.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd)) {
-            (*points)[0] = p3;
-            *points += 1;
-            return 1;
-        }
+        (*points)[0] = p3;
+        *points += 1;
+        return 1;
+    }
     SkPoint q[] = {
         { SkScalarAve(p0.fX, p1.fX), SkScalarAve(p0.fY, p1.fY) },
         { SkScalarAve(p1.fX, p2.fX), SkScalarAve(p1.fY, p2.fY) },
         { SkScalarAve(p2.fX, p3.fX), SkScalarAve(p2.fY, p3.fY) }
     };
     SkPoint r[] = {
         { SkScalarAve(q[0].fX, q[1].fX), SkScalarAve(q[0].fY, q[1].fY) },
         { SkScalarAve(q[1].fX, q[2].fX), SkScalarAve(q[1].fY, q[2].fY) }
     };
     SkPoint s = { SkScalarAve(r[0].fX, r[1].fX), SkScalarAve(r[0].fY, r[1].fY) };
@@ skipping 251 matching lines @@
                                        SkPathPriv::FirstDirection dir,
                                        SkTArray<SkPoint, true>* quads,
                                        int sublevel = 0) {
 
     // Notation: Point a is always p[0]. Point b is p[1] unless p[1] == p[0], in which case it is
     // p[2]. Point d is always p[3]. Point c is p[2] unless p[2] == p[3], in which case it is p[1].
 
     SkVector ab = p[1] - p[0];
     SkVector dc = p[2] - p[3];
 
-    if (ab.isZero()) {
-        if (dc.isZero()) {
+    if (ab.lengthSqd() < SK_ScalarNearlyZero) {
+        if (dc.lengthSqd() < SK_ScalarNearlyZero) {
             SkPoint* degQuad = quads->push_back_n(3);
             degQuad[0] = p[0];
             degQuad[1] = p[0];
             degQuad[2] = p[3];
             return;
         }
         ab = p[2] - p[0];
     }
-    if (dc.isZero()) {
+    if (dc.lengthSqd() < SK_ScalarNearlyZero) {
         dc = p[1] - p[3];
     }
 
     // When the ab and cd tangents are degenerate or nearly parallel with vector from d to a the
     // constraint that the quad point falls between the tangents becomes hard to enforce and we are
     // likely to hit the max subdivision count. However, in this case the cubic is approaching a
     // line and the accuracy of the quad point isn't so important. We check if the two middle cubic
     // control points are very close to the baseline vector. If so then we just pick quadratic
     // points on the control polygon.
 
@@ skipping 375 matching lines @@
         set_loop_klm(d, controlK, controlL, controlM);
     } else if (kCusp_SkCubicType == cType) {
         SkASSERT(0.f == d[0]);
         set_cusp_klm(d, controlK, controlL, controlM);
     } else if (kQuadratic_SkCubicType == cType) {
         set_quadratic_klm(d, controlK, controlL, controlM);
     }
 
     calc_cubic_klm(p, controlK, controlL, controlM, klm, &klm[3], &klm[6]);
 }