move parts of SkPoint to SkPointPriv

Move specialized SkPoint methods to SkPointPriv.
Use constexpr and inline initialization where possible.

R=reed@google.com,bsalomon@google.com
Bug: skia: 6898
Change-Id: I01ec5186f010f2dc80c068c70d9cc352f3221338
Reviewed-on: https://skia-review.googlesource.com/68700
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Ravi Mistry <rmistry@google.com>

1 files changed, 22 insertions, 42 deletions

diff --git a/src/core/SkPoint.cpp b/src/core/SkPoint.cpp
index 4c66b44bac..8992a58b1b 100644
--- a/src/core/SkPoint.cpp
+++ b/src/core/SkPoint.cpp
@@ -7,8 +7,9 @@
 
 
 #include "SkMathPriv.h"
-#include "SkPoint.h"
+#include "SkPointPriv.h"
 
+#if 0
 void SkIPoint::rotateCW(SkIPoint* dst) const {
     SkASSERT(dst);
 
@@ -26,27 +27,10 @@ void SkIPoint::rotateCCW(SkIPoint* dst) const {
     dst->fX = fY;
     dst->fY = -tmp;
 }
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkPoint::rotateCW(SkPoint* dst) const {
-    SkASSERT(dst);
-
-    // use a tmp in case this == dst
-    SkScalar tmp = fX;
-    dst->fX = -fY;
-    dst->fY = tmp;
-}
-
-void SkPoint::rotateCCW(SkPoint* dst) const {
-    SkASSERT(dst);
-
-    // use a tmp in case this == dst
-    SkScalar tmp = fX;
-    dst->fX = fY;
-    dst->fY = -tmp;
-}
-
 void SkPoint::scale(SkScalar scale, SkPoint* dst) const {
     SkASSERT(dst);
     dst->set(fX * scale, fY * scale);
@@ -164,14 +148,10 @@ bool SkPoint::setLength(float x, float y, float length) {
     return true;
 }
 
-bool SkPoint::setLengthFast(float length) {
-    return this->setLengthFast(fX, fY, length);
-}
-
-bool SkPoint::setLengthFast(float x, float y, float length) {
+bool SkPointPriv::SetLengthFast(SkPoint* pt, float length) {
     float mag2;
-    if (is_length_nearly_zero(x, y, &mag2)) {
-        this->set(0, 0);
+    if (is_length_nearly_zero(pt->fX, pt->fY, &mag2)) {
+        pt->set(0, 0);
         return false;
     }
 
@@ -182,30 +162,30 @@ bool SkPoint::setLengthFast(float x, float y, float length) {
         // 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.
-        double xx = x;
-        double yy = y;
+        double xx = pt->fX;
+        double yy = pt->fY;
         scale = (float)(length / sqrt(xx * xx + yy * yy));
     }
-    fX = x * scale;
-    fY = y * scale;
+    pt->fX *= scale;
+    pt->fY *= scale;
     return true;
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkScalar SkPoint::distanceToLineBetweenSqd(const SkPoint& a,
+SkScalar SkPointPriv::DistanceToLineBetweenSqd(const SkPoint& pt, const SkPoint& a,
                                            const SkPoint& b,
-                                           Side* side) const {
+                                           Side* side) {
 
     SkVector u = b - a;
-    SkVector v = *this - a;
+    SkVector v = pt - a;
 
-    SkScalar uLengthSqd = u.lengthSqd();
+    SkScalar uLengthSqd = LengthSqd(u);
     SkScalar det = u.cross(v);
     if (side) {
-        SkASSERT(-1 == SkPoint::kLeft_Side &&
-                  0 == SkPoint::kOn_Side &&
+        SkASSERT(-1 == kLeft_Side &&
+                  0 == kOn_Side &&
                   1 == kRight_Side);
         *side = (Side) SkScalarSignAsInt(det);
     }
@@ -214,8 +194,8 @@ SkScalar SkPoint::distanceToLineBetweenSqd(const SkPoint& a,
     return temp;
 }
 
-SkScalar SkPoint::distanceToLineSegmentBetweenSqd(const SkPoint& a,
-                                                  const SkPoint& b) const {
+SkScalar SkPointPriv::DistanceToLineSegmentBetweenSqd(const SkPoint& pt, const SkPoint& a,
+                                                  const SkPoint& b) {
     // See comments to distanceToLineBetweenSqd. If the projection of c onto
     // u is between a and b then this returns the same result as that
     // function. Otherwise, it returns the distance to the closer of a and
@@ -233,15 +213,15 @@ SkScalar SkPoint::distanceToLineSegmentBetweenSqd(const SkPoint& a,
     // avoid a sqrt to compute |u|.
 
     SkVector u = b - a;
-    SkVector v = *this - a;
+    SkVector v = pt - a;
 
-    SkScalar uLengthSqd = u.lengthSqd();
+    SkScalar uLengthSqd = LengthSqd(u);
     SkScalar uDotV = SkPoint::DotProduct(u, v);
 
     if (uDotV <= 0) {
-        return v.lengthSqd();
+        return LengthSqd(v);
     } else if (uDotV > uLengthSqd) {
-        return b.distanceToSqd(*this);
+        return DistanceToSqd(b, pt);
     } else {
         SkScalar det = u.cross(v);
         SkScalar temp = det / uLengthSqd;