Handle stroked single line special case in Ganesh

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"
 #include "SkPoint.h"
@@ skipping 70 matching lines @@
 static inline float getLengthSquared(float dx, float dy) {
     return dx * dx + dy * dy;
 }
 
 // Calculates the square of the Euclidian distance to (dx,dy) and stores it in
 // *lengthSquared.  Returns true if the distance is judged to be "nearly zero".
 //
 // This logic is encapsulated in a helper method to make it explicit that we
 // always perform this check in the same manner, to avoid inconsistencies
 // (see http://code.google.com/p/skia/issues/detail?id=560 ).
-static inline bool isLengthNearlyZero(float dx, float dy,
-                                      float *lengthSquared) {
+static inline bool is_length_nearly_zero(float dx, float dy,
+                                         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)) {
+    if (is_length_nearly_zero(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.
@@ 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)) {
+    if (is_length_nearly_zero(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
@@ skipping 16 matching lines @@
     fY = y * scale;
     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)) {
+    if (is_length_nearly_zero(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
@@ skipping 58 matching lines @@
         return v.lengthSqd();
     } else if (uDotV > uLengthSqd) {
         return b.distanceToSqd(*this);
     } else {
         SkScalar det = u.cross(v);
         SkScalar temp = det / uLengthSqd;
         temp *= det;
         return temp;
     }
 }