change SkPoint::setLength to set itself to (0,0) if it starting length is degenerate

src/core/SkPoint.cpp

 
 /*
  * Copyright 2008 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 "SkMathPriv.h"
@@ skipping 82 matching lines @@
                                       float *lengthSquared) {
     *lengthSquared = getLengthSquared(dx, dy);
     return *lengthSquared <= (SK_ScalarNearlyZero * SK_ScalarNearlyZero);
 }
 
 SkScalar SkPoint::Normalize(SkPoint* pt) {
     float x = pt->fX;
     float y = pt->fY;
     float mag2;
     if (isLengthNearlyZero(x, y, &mag2)) {
+        pt->set(0, 0);
         return 0;
     }
 
     float mag, scale;
     if (SkScalarIsFinite(mag2)) {
         mag = sk_float_sqrt(mag2);
         scale = 1 / mag;
     } else {
         // our mag2 step overflowed to infinity, so use doubles instead.
         // much slower, but needed when x or y are very large, other wise we
@@ skipping 27 matching lines @@
  *  We have to worry about 2 tricky conditions:
  *  1. underflow of mag2 (compared against nearlyzero^2)
  *  2. overflow of mag2 (compared w/ isfinite)
  *
  *  If we underflow, we return false. If we overflow, we compute again using
  *  doubles, which is much slower (3x in a desktop test) but will not overflow.
  */
 bool SkPoint::setLength(float x, float y, float length) {
     float mag2;
     if (isLengthNearlyZero(x, y, &mag2)) {
+        this->set(0, 0);
         return false;
     }
 
     float scale;
     if (SkScalarIsFinite(mag2)) {
         scale = length / sk_float_sqrt(mag2);
     } else {
         // our mag2 step overflowed to infinity, so use doubles instead.
         // much slower, but needed when x or y are very large, other wise we
         // divide by inf. and return (0,0) vector.
@@ skipping 16 matching lines @@
     return true;
 }
 
 bool SkPoint::setLengthFast(float length) {
     return this->setLengthFast(fX, fY, length);
 }
 
 bool SkPoint::setLengthFast(float x, float y, float length) {
     float mag2;
     if (isLengthNearlyZero(x, y, &mag2)) {
+        this->set(0, 0);
         return false;
     }
 
     float scale;
     if (SkScalarIsFinite(mag2)) {
         scale = length * sk_float_rsqrt(mag2);  // <--- this is the difference
     } else {
         // our mag2 step overflowed to infinity, so use doubles instead.
         // much slower, but needed when x or y are very large, other wise we
         // divide by inf. and return (0,0) vector.
@@ skipping 53 matching lines @@
 
     if (uDotV <= 0) {
         return v.lengthSqd();
     } else if (uDotV > uLengthSqd) {
         return b.distanceToSqd(*this);
     } else {
         SkScalar det = u.cross(v);
         return SkScalarMulDiv(det, det, uLengthSqd);
     }
 }