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

include/core/SkPoint.h

 /*
  * 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.
  */
 
 #ifndef SkPoint_DEFINED
 #define SkPoint_DEFINED
 
@@ skipping 240 matching lines @@
         // Simple enough (and performance critical sometimes) so we inline it.
         return (dx*dx + dy*dy) > (SK_ScalarNearlyZero * SK_ScalarNearlyZero);
     }
 
     bool canNormalize() const {
         return CanNormalize(fX, fY);
     }
 
     /** Set the point (vector) to be unit-length in the same direction as it
         already points.  If the point has a degenerate length (i.e. nearly 0)
-        then return false and do nothing; otherwise return true.
+        then set it to (0,0) and return false; otherwise return true.
     */
     bool normalize();
 
     /** Set the point (vector) to be unit-length in the same direction as the
         x,y params. If the vector (x,y) has a degenerate length (i.e. nearly 0)
-        then return false and do nothing, otherwise return true.
+        then set it to (0,0) and return false, otherwise return true.
     */
     bool setNormalize(SkScalar x, SkScalar y);
 
     /** Scale the point (vector) to have the specified length, and return that
         length. If the original length is degenerately small (nearly zero),
-        do nothing and return false, otherwise return true.
+        set it to (0,0) and return false, otherwise return true.
     */
     bool setLength(SkScalar length);
 
     /** Set the point (vector) to have the specified length in the same
      direction as (x,y). If the vector (x,y) has a degenerate length
-     (i.e. nearly 0) then return false and do nothing, otherwise return true.
+     (i.e. nearly 0) then set it to (0,0) and return false, otherwise return true.
     */
     bool setLength(SkScalar x, SkScalar y, SkScalar length);
 
     /** Same as setLength, but favoring speed over accuracy.
     */
     bool setLengthFast(SkScalar length);
 
     /** Same as setLength, but favoring speed over accuracy.
     */
     bool setLengthFast(SkScalar x, SkScalar y, SkScalar length);
@@ skipping 126 matching lines @@
         SkPoint v;
         v.set(a.fX + b.fX, a.fY + b.fY);
         return v;
     }
 
     /** Returns the euclidian distance from (0,0) to (x,y)
     */
     static SkScalar Length(SkScalar x, SkScalar y);
 
     /** Normalize pt, returning its previous length. If the prev length is too
-        small (degenerate), return 0 and leave pt unchanged. This uses the same
+        small (degenerate), set pt to (0,0) and return 0. This uses the same
         tolerance as CanNormalize.
 
         Note that this method may be significantly more expensive than
         the non-static normalize(), because it has to return the previous length
         of the point.  If you don't need the previous length, call the
         non-static normalize() method instead.
      */
     static SkScalar Normalize(SkPoint* pt);
 
     /** Returns the euclidian distance between a and b
@@ skipping 96 matching lines @@
 
     /**
      *  cast-safe way to treat the point as an array of (2) SkScalars.
      */
     const SkScalar* asScalars() const { return &fX; }
 };
 
 typedef SkPoint SkVector;
 
 #endif