diff --git a/gm/OverStroke.cpp b/gm/OverStroke.cpp
index f7134cd..6827890 100644
--- a/gm/OverStroke.cpp
+++ b/gm/OverStroke.cpp
@@ -27,6 +27,7 @@
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPathMeasure.h"
+#include "SkPointPriv.h"
 
 const SkScalar OVERSTROKE_WIDTH = 500.0f;
 const SkScalar NORMALSTROKE_WIDTH = 3.0f;
@@ -96,7 +97,7 @@
     while (accum < length) {
         if (meas.getPosTan(accum, &pos, &tan)) {
             tan.scale(radius);
-            tan.rotateCCW();
+            SkPointPriv::RotateCCW(&tan);
 
             ribs.moveTo(pos.x() + tan.x(), pos.y() + tan.y());
             ribs.lineTo(pos.x() - tan.x(), pos.y() - tan.y());
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index d39d4ef..25aa7fc 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -421,9 +421,7 @@
         @param exact  if false, allow nearly equals
         @return       true if line is degenerate; its length is effectively zero
     */
-    static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact) {
-        return exact ? p1 == p2 : p1.equalsWithinTolerance(p2);
-    }
+    static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact);
 
     /** Test if quad is degenerate.
         Quad with no length or that moves a very short distance is degenerate; it is
@@ -437,10 +435,7 @@
         @return       true if quad is degenerate; its length is effectively zero
     */
     static bool IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2,
-                                 const SkPoint& p3, bool exact) {
-        return exact ? p1 == p2 && p2 == p3 : p1.equalsWithinTolerance(p2) &&
-               p2.equalsWithinTolerance(p3);
-    }
+                                 const SkPoint& p3, bool exact);
 
     /** Test if cubic is degenerate.
         Cubic with no length or that moves a very short distance is degenerate; it is
@@ -455,11 +450,7 @@
         @return       true if cubic is degenerate; its length is effectively zero
     */
     static bool IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2,
-                                  const SkPoint& p3, const SkPoint& p4, bool exact) {
-        return exact ? p1 == p2 && p2 == p3 && p3 == p4 : p1.equalsWithinTolerance(p2) &&
-               p2.equalsWithinTolerance(p3) &&
-               p3.equalsWithinTolerance(p4);
-    }
+                                  const SkPoint& p3, const SkPoint& p4, bool exact);
 
     /** Returns true if SkPath contains only one line;
         SkPath::Verb array has two entries: kMove_Verb, kLine_Verb.
diff --git a/include/core/SkPoint.h b/include/core/SkPoint.h
index f9527bf..744abb7 100644
--- a/include/core/SkPoint.h
+++ b/include/core/SkPoint.h
@@ -19,10 +19,8 @@
     int16_t fX;
     int16_t fY;
 
-    static SkIPoint16 Make(int x, int y) {
-        SkIPoint16 pt;
-        pt.set(x, y);
-        return pt;
+    static constexpr SkIPoint16 Make(int x, int y) {
+        return {SkToS16(x), SkToS16(y)};
     }
 
     int16_t x() const { return fX; }
@@ -42,62 +40,29 @@
     int32_t fX;
     int32_t fY;
 
-    static SkIPoint Make(int32_t x, int32_t y) {
-        SkIPoint pt;
-        pt.set(x, y);
-        return pt;
+    static constexpr SkIPoint Make(int32_t x, int32_t y) {
+        return {x, y};
     }
 
     int32_t x() const { return fX; }
     int32_t y() const { return fY; }
-    void setX(int32_t x) { fX = x; }
-    void setY(int32_t y) { fY = y; }
 
     /**
      *  Returns true iff fX and fY are both zero.
      */
     bool isZero() const { return (fX | fY) == 0; }
 
-    /**
-     *  Set both fX and fY to zero. Same as set(0, 0)
-     */
-    void setZero() { fX = fY = 0; }
-
     /** Set the x and y values of the point. */
-    void set(int32_t x, int32_t y) { fX = x; fY = y; }
-
-    /** Rotate the point clockwise, writing the new point into dst
-        It is legal for dst == this
-    */
-    void rotateCW(SkIPoint* dst) const;
-
-    /** Rotate the point clockwise, writing the new point back into the point
-    */
-
-    void rotateCW() { this->rotateCW(this); }
-
-    /** Rotate the point counter-clockwise, writing the new point into dst.
-        It is legal for dst == this
-    */
-    void rotateCCW(SkIPoint* dst) const;
-
-    /** Rotate the point counter-clockwise, writing the new point back into
-        the point
-    */
-    void rotateCCW() { this->rotateCCW(this); }
-
-    /** Negate the X and Y coordinates of the point.
-    */
-    void negate() { fX = -fX; fY = -fY; }
+    void set(int32_t x, int32_t y) {
+        fX = x;
+        fY = y;
+    }
 
     /** Return a new point whose X and Y coordinates are the negative of the
         original point's
     */
     SkIPoint operator-() const {
-        SkIPoint neg;
-        neg.fX = -fX;
-        neg.fY = -fY;
-        return neg;
+        return {-fX, -fY};
     }
 
     /** Add v's coordinates to this point's */
@@ -129,29 +94,13 @@
         a and b (i.e. a - b)
     */
     friend SkIPoint operator-(const SkIPoint& a, const SkIPoint& b) {
-        SkIPoint v;
-        v.set(a.fX - b.fX, a.fY - b.fY);
-        return v;
+        return {a.fX - b.fX, a.fY - b.fY};
     }
 
     /** Returns a new point whose coordinates are the sum of a and b (a + b)
     */
     friend SkIPoint operator+(const SkIPoint& a, const SkIPoint& b) {
-        SkIPoint v;
-        v.set(a.fX + b.fX, a.fY + b.fY);
-        return v;
-    }
-
-    /** Returns the dot product of a and b, treating them as 2D vectors
-    */
-    static int32_t DotProduct(const SkIPoint& a, const SkIPoint& b) {
-        return a.fX * b.fX + a.fY * b.fY;
-    }
-
-    /** Returns the cross product of a and b, treating them as 2D vectors
-    */
-    static int32_t CrossProduct(const SkIPoint& a, const SkIPoint& b) {
-        return a.fX * b.fY - a.fY * b.fX;
+        return {a.fX + b.fX, a.fY + b.fY};
     }
 };
 
@@ -159,10 +108,8 @@
     SkScalar    fX;
     SkScalar    fY;
 
-    static SkPoint Make(SkScalar x, SkScalar y) {
-        SkPoint pt;
-        pt.set(x, y);
-        return pt;
+    static constexpr SkPoint Make(SkScalar x, SkScalar y) {
+        return {x, y};
     }
 
     SkScalar x() const { return fX; }
@@ -174,7 +121,10 @@
     bool isZero() const { return (0 == fX) & (0 == fY); }
 
     /** Set the point's X and Y coordinates */
-    void set(SkScalar x, SkScalar y) { fX = x; fY = y; }
+    void set(SkScalar x, SkScalar y) {
+        fX = x;
+        fY = y;
+    }
 
     /** Set the point's X and Y coordinates by automatically promoting (x,y) to
         SkScalar values.
@@ -217,19 +167,6 @@
     SkScalar length() const { return SkPoint::Length(fX, fY); }
     SkScalar distanceToOrigin() const { return this->length(); }
 
-    /**
-     *  Return true if the computed length of the vector is >= the internal
-     *  tolerance (used to avoid dividing by tiny values).
-     */
-    static bool CanNormalize(SkScalar dx, SkScalar dy) {
-        // 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 set it to (0,0) and return false; otherwise return true.
@@ -254,14 +191,6 @@
     */
     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);
-
     /** Scale the point's coordinates by scale, writing the answer into dst.
         It is legal for dst == this.
     */
@@ -272,26 +201,6 @@
     */
     void scale(SkScalar value) { this->scale(value, this); }
 
-    /** Rotate the point clockwise by 90 degrees, writing the answer into dst.
-        It is legal for dst == this.
-    */
-    void rotateCW(SkPoint* dst) const;
-
-    /** Rotate the point clockwise by 90 degrees, writing the answer back into
-        the point.
-    */
-    void rotateCW() { this->rotateCW(this); }
-
-    /** Rotate the point counter-clockwise by 90 degrees, writing the answer
-        into dst. It is legal for dst == this.
-    */
-    void rotateCCW(SkPoint* dst) const;
-
-    /** Rotate the point counter-clockwise by 90 degrees, writing the answer
-        back into the point.
-    */
-    void rotateCCW() { this->rotateCCW(this); }
-
     /** Negate the point's coordinates
     */
     void negate() {
@@ -302,10 +211,7 @@
     /** Returns a new point whose coordinates are the negative of the point's
     */
     SkPoint operator-() const {
-        SkPoint neg;
-        neg.fX = -fX;
-        neg.fY = -fY;
-        return neg;
+        return {-fX, -fY};
     }
 
     /** Add v's coordinates to the point's
@@ -323,7 +229,7 @@
     }
 
     SkPoint operator*(SkScalar scale) const {
-        return Make(fX * scale, fY * scale);
+        return {fX * scale, fY * scale};
     }
 
     SkPoint& operator*=(SkScalar scale) {
@@ -363,43 +269,17 @@
         return a.fX != b.fX || a.fY != b.fY;
     }
 
-    /** Return true if this point and the given point are far enough apart
-        such that a vector between them would be non-degenerate.
-
-        WARNING: Unlike the explicit tolerance version,
-        this method does not use componentwise comparison.  Instead, it
-        uses a comparison designed to match judgments elsewhere regarding
-        degeneracy ("points A and B are so close that the vector between them
-        is essentially zero").
-    */
-    bool equalsWithinTolerance(const SkPoint& p) const {
-        return !CanNormalize(fX - p.fX, fY - p.fY);
-    }
-
-    /** WARNING: There is no guarantee that the result will reflect judgments
-        elsewhere regarding degeneracy ("points A and B are so close that the
-        vector between them is essentially zero").
-    */
-    bool equalsWithinTolerance(const SkPoint& p, SkScalar tol) const {
-        return SkScalarNearlyZero(fX - p.fX, tol)
-               && SkScalarNearlyZero(fY - p.fY, tol);
-    }
-
     /** Returns a new point whose coordinates are the difference between
         a's and b's (a - b)
     */
     friend SkPoint operator-(const SkPoint& a, const SkPoint& b) {
-        SkPoint v;
-        v.set(a.fX - b.fX, a.fY - b.fY);
-        return v;
+        return {a.fX - b.fX, a.fY - b.fY};
     }
 
     /** Returns a new point whose coordinates are the sum of a's and b's (a + b)
     */
     friend SkPoint operator+(const SkPoint& a, const SkPoint& b) {
-        SkPoint v;
-        v.set(a.fX + b.fX, a.fY + b.fY);
-        return v;
+        return {a.fX + b.fX, a.fY + b.fY};
     }
 
     /** Returns the euclidian distance from (0,0) to (x,y)
@@ -443,88 +323,8 @@
         return DotProduct(*this, vec);
     }
 
-    SkScalar lengthSqd() const {
-        return DotProduct(*this, *this);
-    }
-
-    SkScalar distanceToSqd(const SkPoint& pt) const {
-        SkScalar dx = fX - pt.fX;
-        SkScalar dy = fY - pt.fY;
-        return dx * dx + dy * dy;
-    }
-
-    /**
-     * The side of a point relative to a line. If the line is from a to b then
-     * the values are consistent with the sign of (b-a) cross (pt-a)
-     */
-    enum Side {
-        kLeft_Side  = -1,
-        kOn_Side    =  0,
-        kRight_Side =  1,
-    };
-
-    /**
-     * Returns the squared distance to the infinite line between two pts. Also
-     * optionally returns the side of the line that the pt falls on (looking
-     * along line from a to b)
-     */
-    SkScalar distanceToLineBetweenSqd(const SkPoint& a,
-                                      const SkPoint& b,
-                                      Side* side = nullptr) const;
-
-    /**
-     * Returns the distance to the infinite line between two pts. Also
-     * optionally returns the side of the line that the pt falls on (looking
-     * along the line from a to b)
-     */
-    SkScalar distanceToLineBetween(const SkPoint& a,
-                                   const SkPoint& b,
-                                   Side* side = nullptr) const {
-        return SkScalarSqrt(this->distanceToLineBetweenSqd(a, b, side));
-    }
-
-    /**
-     * Returns the squared distance to the line segment between pts a and b
-     */
-    SkScalar distanceToLineSegmentBetweenSqd(const SkPoint& a,
-                                             const SkPoint& b) const;
-
-    /**
-     * Returns the distance to the line segment between pts a and b.
-     */
-    SkScalar distanceToLineSegmentBetween(const SkPoint& a,
-                                          const SkPoint& b) const {
-        return SkScalarSqrt(this->distanceToLineSegmentBetweenSqd(a, b));
-    }
-
-    /**
-     * Make this vector be orthogonal to vec. Looking down vec the
-     * new vector will point in direction indicated by side (which
-     * must be kLeft_Side or kRight_Side).
-     */
-    void setOrthog(const SkPoint& vec, Side side = kLeft_Side) {
-        // vec could be this
-        SkScalar tmp = vec.fX;
-        if (kRight_Side == side) {
-            fX = -vec.fY;
-            fY = tmp;
-        } else {
-            SkASSERT(kLeft_Side == side);
-            fX = vec.fY;
-            fY = -tmp;
-        }
-    }
-
-    /**
-     *  cast-safe way to treat the point as an array of (2) SkScalars.
-     */
-    const SkScalar* asScalars() const { return &fX; }
 };
 
 typedef SkPoint SkVector;
 
-static inline bool SkPointsAreFinite(const SkPoint array[], int count) {
-    return SkScalarsAreFinite(&array[0].fX, count << 1);
-}
-
 #endif
diff --git a/include/core/SkRRect.h b/include/core/SkRRect.h
index 28b3fc4..06edab9 100644
--- a/include/core/SkRRect.h
+++ b/include/core/SkRRect.h
@@ -234,15 +234,11 @@
     }
 
     friend bool operator==(const SkRRect& a, const SkRRect& b) {
-        return a.fRect == b.fRect &&
-               SkScalarsEqual(a.fRadii[0].asScalars(),
-                              b.fRadii[0].asScalars(), 8);
+        return a.fRect == b.fRect && SkScalarsEqual(&a.fRadii[0].fX, &b.fRadii[0].fX, 8);
     }
 
     friend bool operator!=(const SkRRect& a, const SkRRect& b) {
-        return a.fRect != b.fRect ||
-               !SkScalarsEqual(a.fRadii[0].asScalars(),
-                               b.fRadii[0].asScalars(), 8);
+        return a.fRect != b.fRect || !SkScalarsEqual(&a.fRadii[0].fX, &b.fRadii[0].fX, 8);
     }
 
     /**
diff --git a/samplecode/SampleAAGeometry.cpp b/samplecode/SampleAAGeometry.cpp
index da96a0b..55aebda 100644
--- a/samplecode/SampleAAGeometry.cpp
+++ b/samplecode/SampleAAGeometry.cpp
@@ -13,6 +13,7 @@
 #include "SkOpEdgeBuilder.h"
 // #include "SkPathOpsSimplifyAA.h"
 // #include "SkPathStroker.h"
+#include "SkPointPriv.h"
 #include "SkView.h"
 
 #if 0
@@ -1299,7 +1300,7 @@
     SkScalar pt_to_line(SkPoint s, SkPoint e, int x, int y) {
         SkScalar radius = fWidthControl.fValLo;
         SkVector adjOpp = e - s;
-        SkScalar lenSq = adjOpp.lengthSqd();
+        SkScalar lenSq = SkPointPriv::LengthSqd(adjOpp);
         SkPoint rotated = {
                 (y - s.fY) * adjOpp.fY + (x - s.fX) * adjOpp.fX,
                 (y - s.fY) * adjOpp.fX - (x - s.fX) * adjOpp.fY,
diff --git a/samplecode/SampleFatBits.cpp b/samplecode/SampleFatBits.cpp
index 80f656e..723dca8 100644
--- a/samplecode/SampleFatBits.cpp
+++ b/samplecode/SampleFatBits.cpp
@@ -10,6 +10,7 @@
 #include "SkView.h"
 #include "SkCanvas.h"
 #include "SkPath.h"
+#include "SkPointPriv.h"
 #include "SkRegion.h"
 #include "SkShader.h"
 #include "SkUtils.h"
@@ -483,7 +484,7 @@
         SkScalar tol = 12;
 
         for (int i = 0; i < count; ++i) {
-            if (fPts[i].equalsWithinTolerance(pt, tol)) {
+            if (SkPointPriv::EqualsWithinTolerance(fPts[i], pt, tol)) {
                 index = i;
                 break;
             }
diff --git a/samplecode/SampleHT.cpp b/samplecode/SampleHT.cpp
index 50ea287..e1483be 100644
--- a/samplecode/SampleHT.cpp
+++ b/samplecode/SampleHT.cpp
@@ -12,6 +12,7 @@
 #include "SkDrawable.h"
 #include "SkInterpolator.h"
 #include "SkPictureRecorder.h"
+#include "SkPointPriv.h"
 #include "SkRandom.h"
 
 const SkRect gUnitSquare = { -1, -1, 1, 1 };
@@ -35,7 +36,7 @@
     m.setRectToRect(r, gUnitSquare, SkMatrix::kFill_ScaleToFit);
     SkPoint pt;
     m.mapXY(x, y, &pt);
-    return pt.lengthSqd() <= 1;
+    return SkPointPriv::LengthSqd(pt) <= 1;
 }
 
 static SkColor rand_opaque_color(uint32_t seed) {
diff --git a/samplecode/SampleQuadStroker.cpp b/samplecode/SampleQuadStroker.cpp
index ea5f97f..fa45d6e 100644
--- a/samplecode/SampleQuadStroker.cpp
+++ b/samplecode/SampleQuadStroker.cpp
@@ -11,6 +11,7 @@
 #include "SkCanvas.h"
 #include "SkGeometry.h"
 #include "SkPathMeasure.h"
+#include "SkPointPriv.h"
 #include "SkRandom.h"
 #include "SkRRect.h"
 #include "SkColorPriv.h"
@@ -313,7 +314,7 @@
         for (SkScalar dist = 0; dist <= total; dist += delta) {
             if (meas.getPosTan(dist, &pos, &tan)) {
                 tan.scale(radius);
-                tan.rotateCCW();
+                SkPointPriv::RotateCCW(&tan);
                 canvas->drawLine(pos.x() + tan.x(), pos.y() + tan.y(),
                                  pos.x() - tan.x(), pos.y() - tan.y(), paint);
                 if (0 == index % 10) {
@@ -375,7 +376,7 @@
                     return;
             }
             tan.setLength(radius);
-            tan.rotateCCW();
+            SkPointPriv::RotateCCW(&tan);
             canvas->drawLine(pos.x() + tan.x(), pos.y() + tan.y(),
                                 pos.x() - tan.x(), pos.y() - tan.y(), paint);
             if (0 == index % 10) {
@@ -556,8 +557,8 @@
         before.setLength(fRadius);
         after.setLength(fRadius);
         SkVector beforeCCW, afterCCW;
-        before.rotateCCW(&beforeCCW);
-        after.rotateCCW(&afterCCW);
+        SkPointPriv::RotateCCW(before, &beforeCCW);
+        SkPointPriv::RotateCCW(after, &afterCCW);
         beforeCCW += pts[0];
         afterCCW += pts[2];
         *center = beforeCCW;
@@ -566,8 +567,8 @@
             return true;
         }
         SkVector beforeCW, afterCW;
-        before.rotateCW(&beforeCW);
-        after.rotateCW(&afterCW);
+        SkPointPriv::RotateCW(before, &beforeCW);
+        SkPointPriv::RotateCW(after, &afterCW);
         beforeCW += pts[0];
         afterCW += pts[2];
         *center = beforeCW;
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 4c4f76a..2b505fd 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -202,7 +202,7 @@
         this->updatePixelsFromRef();
     } else {
         // ignore dx,dy if there is no pixelref
-        fPixelRefOrigin.setZero();
+        fPixelRefOrigin = {0, 0};
         fPixels = nullptr;
     }
 
@@ -337,7 +337,7 @@
 
 void SkBitmap::freePixels() {
     fPixelRef = nullptr;
-    fPixelRefOrigin.setZero();
+    fPixelRefOrigin = {0, 0};
     fPixels = nullptr;
 }
 
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index b36a73a..5d5c9da 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -32,7 +32,7 @@
     : fInfo(info)
     , fSurfaceProps(surfaceProps)
 {
-    fOrigin.setZero();
+    fOrigin = {0, 0};
     fCTM.reset();
 }
 
diff --git a/src/core/SkDistanceFieldGen.cpp b/src/core/SkDistanceFieldGen.cpp
index f227d6a..9038178 100644
--- a/src/core/SkDistanceFieldGen.cpp
+++ b/src/core/SkDistanceFieldGen.cpp
@@ -7,7 +7,7 @@
 
 #include "SkAutoMalloc.h"
 #include "SkDistanceFieldGen.h"
-#include "SkPoint.h"
+#include "SkPointPriv.h"
 #include "SkTemplates.h"
 
 struct DFData {
@@ -171,7 +171,7 @@
                              + SK_ScalarSqrt2*nextData->fAlpha
                              - SK_ScalarSqrt2*prevData->fAlpha
                              + (nextData+1)->fAlpha - (prevData+1)->fAlpha;
-                currGrad.setLengthFast(1.0f);
+                SkPointPriv::SetLengthFast(&currGrad, 1.0f);
 
                 // init squared distance to edge and distance vector
                 float dist = edge_distance(currGrad, currData->fAlpha);
diff --git a/src/core/SkGeometry.cpp b/src/core/SkGeometry.cpp
index 83208aa..09f304b 100644
--- a/src/core/SkGeometry.cpp
+++ b/src/core/SkGeometry.cpp
@@ -9,6 +9,7 @@
 #include "SkMatrix.h"
 #include "SkNx.h"
 #include "SkPoint3.h"
+#include "SkPointPriv.h"
 
 static SkVector to_vector(const Sk2s& x) {
     SkVector vector;
@@ -1151,7 +1152,7 @@
 #define kMaxConicToQuadPOW2     5
 
 int SkConic::computeQuadPOW2(SkScalar tol) const {
-    if (tol < 0 || !SkScalarIsFinite(tol) || !SkPointsAreFinite(fPts, 3)) {
+    if (tol < 0 || !SkScalarIsFinite(tol) || !SkPointPriv::AreFinite(fPts, 3)) {
         return 0;
     }
 
@@ -1240,8 +1241,8 @@
         SkConic dst[2];
         this->chop(dst);
         // check to see if the first chop generates a pair of lines
-        if (dst[0].fPts[1].equalsWithinTolerance(dst[0].fPts[2])
-                && dst[1].fPts[0].equalsWithinTolerance(dst[1].fPts[1])) {
+        if (SkPointPriv::EqualsWithinTolerance(dst[0].fPts[1], dst[0].fPts[2]) &&
+                SkPointPriv::EqualsWithinTolerance(dst[1].fPts[0], dst[1].fPts[1])) {
             pts[1] = pts[2] = pts[3] = dst[0].fPts[1];  // set ctrl == end to make lines
             pts[4] = dst[1].fPts[2];
             pow2 = 1;
@@ -1254,7 +1255,7 @@
     const int quadCount = 1 << pow2;
     const int ptCount = 2 * quadCount + 1;
     SkASSERT(endPts - pts == ptCount);
-    if (!SkPointsAreFinite(pts, ptCount)) {
+    if (!SkPointPriv::AreFinite(pts, ptCount)) {
         // if we generated a non-finite, pin ourselves to the middle of the hull,
         // as our first and last are already on the first/last pts of the hull.
         for (int i = 1; i < ptCount - 1; ++i) {
@@ -1422,7 +1423,7 @@
         //
         const SkScalar cosThetaOver2 = SkScalarSqrt((1 + dot) / 2);
         offCurve.setLength(SkScalarInvert(cosThetaOver2));
-        if (!lastQ.equalsWithinTolerance(offCurve)) {
+        if (!SkPointPriv::EqualsWithinTolerance(lastQ, offCurve)) {
             dst[conicCount].set(lastQ, offCurve, finalP, cosThetaOver2);
             conicCount += 1;
         }
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index a053c76..1b443b2 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -14,6 +14,7 @@
 #include "SkMatrixPriv.h"
 #include "SkPathPriv.h"
 #include "SkPathRef.h"
+#include "SkPointPriv.h"
 #include "SkRRect.h"
 
 static float poly_eval(float A, float B, float C, float t) {
@@ -2408,7 +2409,7 @@
             ++fPtCount;
         } else {
             SkVector vec = pt - fCurrPt;
-            SkScalar lengthSqd = vec.lengthSqd();
+            SkScalar lengthSqd = SkPointPriv::LengthSqd(vec);
             if (!SkScalarIsFinite(lengthSqd)) {
                 fIsFinite = false;
             } else if (lengthSqd) {
@@ -2470,8 +2471,10 @@
             }
         }
 
-        if (!SkScalarNearlyZero(fLastVec.lengthSqd(), SK_ScalarNearlyZero*SK_ScalarNearlyZero) &&
-            !SkScalarNearlyZero(curVec.lengthSqd(), SK_ScalarNearlyZero*SK_ScalarNearlyZero) &&
+        if (!SkScalarNearlyZero(SkPointPriv::LengthSqd(fLastVec),
+                                SK_ScalarNearlyZero*SK_ScalarNearlyZero) &&
+            !SkScalarNearlyZero(SkPointPriv::LengthSqd(curVec),
+                                SK_ScalarNearlyZero*SK_ScalarNearlyZero) &&
             fLastVec.dot(curVec) < 0.0f) {
             return kBackwards_DirChange;
         }
@@ -3352,7 +3355,7 @@
        if (tangents.count() > oldCount) {
             int last = tangents.count() - 1;
             const SkVector& tangent = tangents[last];
-            if (SkScalarNearlyZero(tangent.lengthSqd())) {
+            if (SkScalarNearlyZero(SkPointPriv::LengthSqd(tangent))) {
                 tangents.remove(last);
             } else {
                 for (int index = 0; index < last; ++index) {
@@ -3601,3 +3604,21 @@
     max.store((SkPoint*)&bounds.fRight);
     return bounds;
 }
+
+bool SkPath::IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact) {
+    return exact ? p1 == p2 : SkPointPriv::EqualsWithinTolerance(p1, p2);
+}
+
+bool SkPath::IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2,
+                                const SkPoint& p3, bool exact) {
+    return exact ? p1 == p2 && p2 == p3 : SkPointPriv::EqualsWithinTolerance(p1, p2) &&
+            SkPointPriv::EqualsWithinTolerance(p2, p3);
+}
+
+bool SkPath::IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2,
+                                const SkPoint& p3, const SkPoint& p4, bool exact) {
+    return exact ? p1 == p2 && p2 == p3 && p3 == p4 :
+            SkPointPriv::EqualsWithinTolerance(p1, p2) &&
+            SkPointPriv::EqualsWithinTolerance(p2, p3) &&
+            SkPointPriv::EqualsWithinTolerance(p3, p4);
+}
diff --git a/src/core/SkPoint.cpp b/src/core/SkPoint.cpp
index 4c66b44..8992a58 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 @@
     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 @@
     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 @@
         // 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 @@
     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 @@
     // 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;
diff --git a/src/core/SkPointPriv.h b/src/core/SkPointPriv.h
index 6685b15..6c8fd48 100644
--- a/src/core/SkPointPriv.h
+++ b/src/core/SkPointPriv.h
@@ -12,6 +12,100 @@
 
 class SkPointPriv {
 public:
+    enum Side {
+        kLeft_Side  = -1,
+        kOn_Side    =  0,
+        kRight_Side =  1,
+    };
+
+    static bool AreFinite(const SkPoint array[], int count) {
+        return SkScalarsAreFinite(&array[0].fX, count << 1);
+    }
+
+    static const SkScalar* AsScalars(const SkPoint& pt) { return &pt.fX; }
+
+    static bool CanNormalize(SkScalar dx, SkScalar dy) {
+        // Simple enough (and performance critical sometimes) so we inline it.
+        return (dx*dx + dy*dy) > (SK_ScalarNearlyZero * SK_ScalarNearlyZero);
+    }
+
+    static SkScalar DistanceToLineBetweenSqd(const SkPoint& pt, const SkPoint& a,
+                                             const SkPoint& b, Side* side = nullptr);
+
+    static SkScalar DistanceToLineBetween(const SkPoint& pt, const SkPoint& a,
+                                          const SkPoint& b, Side* side = nullptr) {
+        return SkScalarSqrt(DistanceToLineBetweenSqd(pt, a, b, side));
+    }
+
+    static SkScalar DistanceToLineSegmentBetweenSqd(const SkPoint& pt, const SkPoint& a,
+                                                   const SkPoint& b);
+
+    static SkScalar DistanceToLineSegmentBetween(const SkPoint& pt, const SkPoint& a,
+                                                 const SkPoint& b) {
+        return SkScalarSqrt(DistanceToLineSegmentBetweenSqd(pt, a, b));
+    }
+
+    static SkScalar DistanceToSqd(const SkPoint& pt, const SkPoint& a) {
+        SkScalar dx = pt.fX - a.fX;
+        SkScalar dy = pt.fY - a.fY;
+        return dx * dx + dy * dy;
+    }
+
+    static bool EqualsWithinTolerance(const SkPoint& p1, const SkPoint& p2) {
+        return !CanNormalize(p1.fX - p2.fX, p1.fY - p2.fY);
+    }
+
+    static bool EqualsWithinTolerance(const SkPoint& pt, const SkPoint& p, SkScalar tol) {
+        return SkScalarNearlyZero(pt.fX - p.fX, tol)
+               && SkScalarNearlyZero(pt.fY - p.fY, tol);
+    }
+
+    static SkScalar LengthSqd(const SkPoint& pt) {
+        return SkPoint::DotProduct(pt, pt);
+    }
+
+    static void Negate(SkIPoint& pt) {
+        pt.fX = -pt.fX;
+        pt.fY = -pt.fY;
+    }
+
+    static void RotateCCW(const SkPoint& src, SkPoint* dst) {
+        // use a tmp in case src == dst
+        SkScalar tmp = src.fX;
+        dst->fX = src.fY;
+        dst->fY = -tmp;
+    }
+
+    static void RotateCCW(SkPoint* pt) {
+        RotateCCW(*pt, pt);
+    }
+
+    static void RotateCW(const SkPoint& src, SkPoint* dst) {
+        // use a tmp in case src == dst
+        SkScalar tmp = src.fX;
+        dst->fX = -src.fY;
+        dst->fY = tmp;
+    }
+
+    static void RotateCW(SkPoint* pt) {
+        RotateCW(*pt, pt);
+    }
+
+    static bool SetLengthFast(SkPoint* pt, float length);
+
+    static void SetOrthog(SkPoint* pt, const SkPoint& vec, Side side = kLeft_Side) {
+        // vec could be this
+        SkScalar tmp = vec.fX;
+        if (kRight_Side == side) {
+            pt->fX = -vec.fY;
+            pt->fY = tmp;
+        } else {
+            SkASSERT(kLeft_Side == side);
+            pt->fX = vec.fY;
+            pt->fY = -tmp;
+        }
+    }
+
     // counter-clockwise fan
     static void SetRectFan(SkPoint v[], SkScalar l, SkScalar t, SkScalar r, SkScalar b,
             size_t stride) {
@@ -33,6 +127,7 @@
         ((SkPoint*)((intptr_t)v + 2 * stride))->set(r, t);
         ((SkPoint*)((intptr_t)v + 3 * stride))->set(r, b);
     }
+
 };
 
 #endif
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index 0852f56..ab8df83 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -8,6 +8,7 @@
 #include "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
+#include "SkPointPriv.h"
 
 enum {
     kTangent_RecursiveLimit,
@@ -48,7 +49,7 @@
 #endif
 
 static inline bool degenerate_vector(const SkVector& v) {
-    return !SkPoint::CanNormalize(v.fX, v.fY);
+    return !SkPointPriv::CanNormalize(v.fX, v.fY);
 }
 
 static bool set_normal_unitnormal(const SkPoint& before, const SkPoint& after, SkScalar scale,
@@ -58,7 +59,7 @@
                                   (after.fY - before.fY) * scale)) {
         return false;
     }
-    unitNormal->rotateCCW();
+    SkPointPriv::RotateCCW(unitNormal);
     unitNormal->scale(radius, normal);
     return true;
 }
@@ -69,7 +70,7 @@
     if (!unitNormal->setNormalize(vec.fX, vec.fY)) {
         return false;
     }
-    unitNormal->rotateCCW();
+    SkPointPriv::RotateCCW(unitNormal);
     unitNormal->scale(radius, normal);
     return true;
 }
@@ -420,7 +421,7 @@
 }
 
 void SkPathStroker::lineTo(const SkPoint& currPt, const SkPath::Iter* iter) {
-    bool teenyLine = fPrevPt.equalsWithinTolerance(currPt, SK_ScalarNearlyZero * fInvResScale);
+    bool teenyLine = SkPointPriv::EqualsWithinTolerance(fPrevPt, currPt, SK_ScalarNearlyZero * fInvResScale);
     if (SkStrokerPriv::CapFactory(SkPaint::kButt_Cap) == fCapper && teenyLine) {
         return;
     }
@@ -489,7 +490,7 @@
 static SkScalar pt_to_line(const SkPoint& pt, const SkPoint& lineStart, const SkPoint& lineEnd) {
     SkVector dxy = lineEnd - lineStart;
     if (degenerate_vector(dxy)) {
-        return pt.distanceToSqd(lineStart);
+        return SkPointPriv::DistanceToSqd(pt, lineStart);
     }
     SkVector ab0 = pt - lineStart;
     SkScalar numer = dxy.dot(ab0);
@@ -498,7 +499,7 @@
     SkPoint hit;
     hit.fX = lineStart.fX * (1 - t) + lineEnd.fX * t;
     hit.fY = lineStart.fY * (1 - t) + lineEnd.fY * t;
-    return hit.distanceToSqd(pt);
+    return SkPointPriv::DistanceToSqd(hit, pt);
 }
 
 /*  Given a cubic, determine if all four points are in a line.
@@ -969,14 +970,14 @@
 }
 
 static bool points_within_dist(const SkPoint& nearPt, const SkPoint& farPt, SkScalar limit) {
-    return nearPt.distanceToSqd(farPt) <= limit * limit;
+    return SkPointPriv::DistanceToSqd(nearPt, farPt) <= limit * limit;
 }
 
 static bool sharp_angle(const SkPoint quad[3]) {
     SkVector smaller = quad[1] - quad[0];
     SkVector larger = quad[1] - quad[2];
-    SkScalar smallerLen = smaller.lengthSqd();
-    SkScalar largerLen = larger.lengthSqd();
+    SkScalar smallerLen = SkPointPriv::LengthSqd(smaller);
+    SkScalar largerLen = SkPointPriv::LengthSqd(larger);
     if (smallerLen > largerLen) {
         SkTSwap(smaller, larger);
         largerLen = smallerLen;
diff --git a/src/core/SkStrokerPriv.cpp b/src/core/SkStrokerPriv.cpp
index 52144cd..be7b1f5 100644
--- a/src/core/SkStrokerPriv.cpp
+++ b/src/core/SkStrokerPriv.cpp
@@ -8,6 +8,7 @@
 #include "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
+#include "SkPointPriv.h"
 
 static void ButtCapper(SkPath* path, const SkPoint& pivot, const SkVector& normal,
                        const SkPoint& stop, SkPath*) {
@@ -17,7 +18,7 @@
 static void RoundCapper(SkPath* path, const SkPoint& pivot, const SkVector& normal,
                         const SkPoint& stop, SkPath*) {
     SkVector parallel;
-    normal.rotateCW(&parallel);
+    SkPointPriv::RotateCW(normal, &parallel);
 
     SkPoint projectedCenter = pivot + parallel;
 
@@ -28,7 +29,7 @@
 static void SquareCapper(SkPath* path, const SkPoint& pivot, const SkVector& normal,
                          const SkPoint& stop, SkPath* otherPath) {
     SkVector parallel;
-    normal.rotateCW(&parallel);
+    SkPointPriv::RotateCW(normal, &parallel);
 
     if (otherPath) {
         path->setLastPt(pivot.fX + normal.fX + parallel.fX, pivot.fY + normal.fY + parallel.fY);
diff --git a/src/effects/SkDiscretePathEffect.cpp b/src/effects/SkDiscretePathEffect.cpp
index b9d76f5..f188bfa 100644
--- a/src/effects/SkDiscretePathEffect.cpp
+++ b/src/effects/SkDiscretePathEffect.cpp
@@ -9,6 +9,7 @@
 #include "SkDiscretePathEffect.h"
 #include "SkFixed.h"
 #include "SkPathMeasure.h"
+#include "SkPointPriv.h"
 #include "SkReadBuffer.h"
 #include "SkStrokeRec.h"
 #include "SkWriteBuffer.h"
@@ -26,7 +27,7 @@
 
 static void Perterb(SkPoint* p, const SkVector& tangent, SkScalar scale) {
     SkVector normal = tangent;
-    normal.rotateCCW();
+    SkPointPriv::RotateCCW(&normal);
     normal.setLength(scale);
     *p += normal;
 }
diff --git a/src/effects/SkMergeImageFilter.cpp b/src/effects/SkMergeImageFilter.cpp
index c84fed7..1d425ed 100644
--- a/src/effects/SkMergeImageFilter.cpp
+++ b/src/effects/SkMergeImageFilter.cpp
@@ -43,7 +43,7 @@
 
     // Filter all of the inputs.
     for (int i = 0; i < inputCount; ++i) {
-        offsets[i].setZero();
+        offsets[i] = { 0, 0 };
         inputs[i] = this->filterInput(i, source, ctx, &offsets[i]);
         if (!inputs[i]) {
             continue;
diff --git a/src/effects/SkOffsetImageFilter.cpp b/src/effects/SkOffsetImageFilter.cpp
index 3852523..a833987 100644
--- a/src/effects/SkOffsetImageFilter.cpp
+++ b/src/effects/SkOffsetImageFilter.cpp
@@ -11,6 +11,7 @@
 #include "SkImageFilterPriv.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
+#include "SkPointPriv.h"
 #include "SkReadBuffer.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
@@ -99,7 +100,7 @@
                                                 MapDirection direction) const {
     SkIPoint vec = map_offset_vector(ctm, fOffset);
     if (kReverse_MapDirection == direction) {
-        vec.negate();
+        SkPointPriv::Negate(vec);
     }
 
     return src.makeOffset(vec.fX, vec.fY);
diff --git a/src/gpu/GrDistanceFieldGenFromVector.cpp b/src/gpu/GrDistanceFieldGenFromVector.cpp
index 8867ab1..fdaeaf2 100644
--- a/src/gpu/GrDistanceFieldGenFromVector.cpp
+++ b/src/gpu/GrDistanceFieldGenFromVector.cpp
@@ -14,7 +14,7 @@
 #include "SkGeometry.h"
 #include "SkMatrix.h"
 #include "SkPathOps.h"
-#include "SkPoint.h"
+#include "SkPointPriv.h"
 
 /**
  * If a scanline (a row of texel) cross from the kRight_SegSide
@@ -370,8 +370,8 @@
 
 static inline void add_quad_segment(const SkPoint pts[3],
                                     PathSegmentArray* segments) {
-    if (pts[0].distanceToSqd(pts[1]) < kCloseSqd ||
-        pts[1].distanceToSqd(pts[2]) < kCloseSqd ||
+    if (SkPointPriv::DistanceToSqd(pts[0], pts[1]) < kCloseSqd ||
+        SkPointPriv::DistanceToSqd(pts[1], pts[2]) < kCloseSqd ||
         is_colinear(pts)) {
         if (pts[0] != pts[2]) {
             SkPoint line_pts[2];
diff --git a/src/gpu/GrPathUtils.cpp b/src/gpu/GrPathUtils.cpp
index f64affb..e36c67c 100644
--- a/src/gpu/GrPathUtils.cpp
+++ b/src/gpu/GrPathUtils.cpp
@@ -9,6 +9,7 @@
 
 #include "GrTypes.h"
 #include "SkMathPriv.h"
+#include "SkPointPriv.h"
 
 static const SkScalar gMinCurveTol = 0.0001f;
 
@@ -41,7 +42,7 @@
     // You should have called scaleToleranceToSrc, which guarantees this
     SkASSERT(tol >= gMinCurveTol);
 
-    SkScalar d = points[1].distanceToLineSegmentBetween(points[0], points[2]);
+    SkScalar d = SkPointPriv::DistanceToLineSegmentBetween(points[1], points[0], points[2]);
     if (!SkScalarIsFinite(d)) {
         return kMaxPointsPerCurve;
     } else if (d <= tol) {
@@ -75,7 +76,7 @@
                                               SkPoint** points,
                                               uint32_t pointsLeft) {
     if (pointsLeft < 2 ||
-        (p1.distanceToLineSegmentBetweenSqd(p0, p2)) < tolSqd) {
+        (SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p2)) < tolSqd) {
         (*points)[0] = p2;
         *points += 1;
         return 1;
@@ -99,8 +100,8 @@
     SkASSERT(tol >= gMinCurveTol);
 
     SkScalar d = SkTMax(
-        points[1].distanceToLineSegmentBetweenSqd(points[0], points[3]),
-        points[2].distanceToLineSegmentBetweenSqd(points[0], points[3]));
+        SkPointPriv::DistanceToLineSegmentBetweenSqd(points[1], points[0], points[3]),
+        SkPointPriv::DistanceToLineSegmentBetweenSqd(points[2], points[0], points[3]));
     d = SkScalarSqrt(d);
     if (!SkScalarIsFinite(d)) {
         return kMaxPointsPerCurve;
@@ -132,8 +133,8 @@
                                           SkPoint** points,
                                           uint32_t pointsLeft) {
     if (pointsLeft < 2 ||
-        (p1.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd &&
-         p2.distanceToLineSegmentBetweenSqd(p0, p3) < tolSqd)) {
+        (SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p3) < tolSqd &&
+         SkPointPriv::DistanceToLineSegmentBetweenSqd(p2, p0, p3) < tolSqd)) {
         (*points)[0] = p3;
         *points += 1;
         return 1;
@@ -226,14 +227,14 @@
         || SkScalarNearlyZero((float)det, SK_ScalarNearlyZero * SK_ScalarNearlyZero)) {
         // The quad is degenerate. Hopefully this is rare. Find the pts that are
         // farthest apart to compute a line (unless it is really a pt).
-        SkScalar maxD = qPts[0].distanceToSqd(qPts[1]);
+        SkScalar maxD = SkPointPriv::DistanceToSqd(qPts[0], qPts[1]);
         int maxEdge = 0;
-        SkScalar d = qPts[1].distanceToSqd(qPts[2]);
+        SkScalar d = SkPointPriv::DistanceToSqd(qPts[1], qPts[2]);
         if (d > maxD) {
             maxD = d;
             maxEdge = 1;
         }
-        d = qPts[2].distanceToSqd(qPts[0]);
+        d = SkPointPriv::DistanceToSqd(qPts[2], qPts[0]);
         if (d > maxD) {
             maxD = d;
             maxEdge = 2;
@@ -245,7 +246,7 @@
             // when looking from the point 0 down the line we want positive
             // distances to be to the left. This matches the non-degenerate
             // case.
-            lineVec.setOrthog(lineVec, SkPoint::kLeft_Side);
+            SkPointPriv::SetOrthog(&lineVec, lineVec, SkPointPriv::kLeft_Side);
             // first row
             fM[0] = 0;
             fM[1] = 0;
@@ -400,8 +401,8 @@
     SkVector ab = p[1] - p[0];
     SkVector dc = p[2] - p[3];
 
-    if (ab.lengthSqd() < SK_ScalarNearlyZero) {
-        if (dc.lengthSqd() < SK_ScalarNearlyZero) {
+    if (SkPointPriv::LengthSqd(ab) < SK_ScalarNearlyZero) {
+        if (SkPointPriv::LengthSqd(dc) < SK_ScalarNearlyZero) {
             SkPoint* degQuad = quads->push_back_n(3);
             degQuad[0] = p[0];
             degQuad[1] = p[0];
@@ -410,7 +411,7 @@
         }
         ab = p[2] - p[0];
     }
-    if (dc.lengthSqd() < SK_ScalarNearlyZero) {
+    if (SkPointPriv::LengthSqd(dc) < SK_ScalarNearlyZero) {
         dc = p[1] - p[3];
     }
 
@@ -423,10 +424,10 @@
 
     if (constrainWithinTangents) {
         SkVector da = p[0] - p[3];
-        bool doQuads = dc.lengthSqd() < SK_ScalarNearlyZero ||
-                       ab.lengthSqd() < SK_ScalarNearlyZero;
+        bool doQuads = SkPointPriv::LengthSqd(dc) < SK_ScalarNearlyZero ||
+                       SkPointPriv::LengthSqd(ab) < SK_ScalarNearlyZero;
         if (!doQuads) {
-            SkScalar invDALengthSqd = da.lengthSqd();
+            SkScalar invDALengthSqd = SkPointPriv::LengthSqd(da);
             if (invDALengthSqd > SK_ScalarNearlyZero) {
                 invDALengthSqd = SkScalarInvert(invDALengthSqd);
                 // cross(ab, da)^2/length(da)^2 == sqd distance from b to line from d to a.
@@ -479,7 +480,7 @@
     SkVector c1 = p[3];
     c1 += dc;
 
-    SkScalar dSqd = sublevel > kMaxSubdivs ? 0 : c0.distanceToSqd(c1);
+    SkScalar dSqd = sublevel > kMaxSubdivs ? 0 : SkPointPriv::DistanceToSqd(c0, c1);
     if (dSqd < toleranceSqd) {
         SkPoint cAvg = c0;
         cAvg += c1;
@@ -490,9 +491,9 @@
         if (constrainWithinTangents &&
             !is_point_within_cubic_tangents(p[0], ab, dc, p[3], dir, cAvg)) {
             // choose a new cAvg that is the intersection of the two tangent lines.
-            ab.setOrthog(ab);
+            SkPointPriv::SetOrthog(&ab, ab);
             SkScalar z0 = -ab.dot(p[0]);
-            dc.setOrthog(dc);
+            SkPointPriv::SetOrthog(&dc, dc);
             SkScalar z1 = -dc.dot(p[3]);
             cAvg.fX = ab.fY * z1 - z0 * dc.fY;
             cAvg.fY = z0 * dc.fX - ab.fX * z1;
@@ -501,8 +502,8 @@
             cAvg.fX *= z;
             cAvg.fY *= z;
             if (sublevel <= kMaxSubdivs) {
-                SkScalar d0Sqd = c0.distanceToSqd(cAvg);
-                SkScalar d1Sqd = c1.distanceToSqd(cAvg);
+                SkScalar d0Sqd = SkPointPriv::DistanceToSqd(c0, cAvg);
+                SkScalar d1Sqd = SkPointPriv::DistanceToSqd(c1, cAvg);
                 // We need to subdivide if d0 + d1 > tolerance but we have the sqd values. We know
                 // the distances and tolerance can't be negative.
                 // (d0 + d1)^2 > toleranceSqd
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index b259d78..53df4be 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1161,8 +1161,8 @@
                                                          rrect.rect().fRight - dr,
                                                          spotShadowRRect.rect().fBottom -
                                                          rrect.rect().fBottom - dr);
-                maxOffset = SkScalarSqrt(SkTMax(upperLeftOffset.lengthSqd(),
-                                                lowerRightOffset.lengthSqd())) + dr;
+                maxOffset = SkScalarSqrt(SkTMax(SkPointPriv::LengthSqd(upperLeftOffset),
+                                                SkPointPriv::LengthSqd(lowerRightOffset))) + dr;
             }
             insetWidth += maxOffset;
         }
diff --git a/src/gpu/GrTessellator.cpp b/src/gpu/GrTessellator.cpp
index a1ea284..a183439 100644
--- a/src/gpu/GrTessellator.cpp
+++ b/src/gpu/GrTessellator.cpp
@@ -13,6 +13,7 @@
 #include "SkArenaAlloc.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
+#include "SkPointPriv.h"
 
 #include <stdio.h>
 
@@ -635,7 +636,7 @@
     if (!p0.isFinite() || !mid.isFinite() || !p1.isFinite()) {
         return 0;
     }
-    return mid.distanceToLineSegmentBetweenSqd(p0, p1);
+    return SkPointPriv::DistanceToLineSegmentBetweenSqd(mid, p0, p1);
 }
 
 void append_quadratic_to_contour(const SkPoint pts[3], SkScalar toleranceSqd, VertexList* contour,
@@ -669,8 +670,8 @@
                            VertexList* contour,
                            int pointsLeft,
                            SkArenaAlloc& alloc) {
-    SkScalar d1 = p1.distanceToLineSegmentBetweenSqd(p0, p3);
-    SkScalar d2 = p2.distanceToLineSegmentBetweenSqd(p0, p3);
+    SkScalar d1 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p1, p0, p3);
+    SkScalar d2 = SkPointPriv::DistanceToLineSegmentBetweenSqd(p2, p0, p3);
     if (pointsLeft < 2 || (d1 < tolSqd && d2 < tolSqd) ||
         !SkScalarIsFinite(d1) || !SkScalarIsFinite(d2)) {
         append_point_to_contour(p3, contour, alloc);
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 0e37238..3c84b32 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -19,6 +19,7 @@
 #include "GrSimpleMeshDrawOpHelper.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
+#include "SkPointPriv.h"
 #include "SkString.h"
 #include "SkTraceEvent.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
@@ -122,11 +123,11 @@
     int count = segments->count();
 
     // Make the normals point towards the outside
-    SkPoint::Side normSide;
+    SkPointPriv::Side normSide;
     if (dir == SkPathPriv::kCCW_FirstDirection) {
-        normSide = SkPoint::kRight_Side;
+        normSide = SkPointPriv::kRight_Side;
     } else {
-        normSide = SkPoint::kLeft_Side;
+        normSide = SkPointPriv::kLeft_Side;
     }
 
     *vCount = 0;
@@ -142,7 +143,7 @@
         for (int p = 0; p < n; ++p) {
             segb.fNorms[p] = segb.fPts[p] - *prevPt;
             segb.fNorms[p].normalize();
-            segb.fNorms[p].setOrthog(segb.fNorms[p], normSide);
+            SkPointPriv::SetOrthog(&segb.fNorms[p], segb.fNorms[p], normSide);
             prevPt = &segb.fPts[p];
         }
         if (Segment::kLine == segb.fType) {
@@ -192,10 +193,10 @@
             data->fStage = DegenerateTestData::kPoint;
             break;
         case DegenerateTestData::kPoint:
-            if (pt.distanceToSqd(data->fFirstPoint) > kCloseSqd) {
+            if (SkPointPriv::DistanceToSqd(pt, data->fFirstPoint) > kCloseSqd) {
                 data->fLineNormal = pt - data->fFirstPoint;
                 data->fLineNormal.normalize();
-                data->fLineNormal.setOrthog(data->fLineNormal);
+                SkPointPriv::SetOrthog(&data->fLineNormal, data->fLineNormal);
                 data->fLineC = -data->fLineNormal.dot(data->fFirstPoint);
                 data->fStage = DegenerateTestData::kLine;
             }
@@ -235,7 +236,8 @@
 
 static inline void add_quad_segment(const SkPoint pts[3],
                                     SegmentArray* segments) {
-    if (pts[0].distanceToSqd(pts[1]) < kCloseSqd || pts[1].distanceToSqd(pts[2]) < kCloseSqd) {
+    if (SkPointPriv::DistanceToSqd(pts[0], pts[1]) < kCloseSqd ||
+        SkPointPriv::DistanceToSqd(pts[1], pts[2]) < kCloseSqd) {
         if (pts[0] != pts[2]) {
             add_line_to_segment(pts[2], segments);
         }
@@ -425,8 +427,8 @@
 
             // we draw the line edge as a degenerate quad (u is 0, v is the
             // signed distance to the edge)
-            SkScalar dist = fanPt.distanceToLineBetween(verts[*v + 1].fPos,
-                                                        verts[*v + 2].fPos);
+            SkScalar dist = SkPointPriv::DistanceToLineBetween(fanPt, verts[*v + 1].fPos,
+                                                               verts[*v + 2].fPos);
             verts[*v + 0].fUV.set(0, dist);
             verts[*v + 1].fUV.set(0, 0);
             verts[*v + 2].fUV.set(0, 0);
diff --git a/src/gpu/ops/GrAAConvexTessellator.cpp b/src/gpu/ops/GrAAConvexTessellator.cpp
index 6c0125a..9927d98 100644
--- a/src/gpu/ops/GrAAConvexTessellator.cpp
+++ b/src/gpu/ops/GrAAConvexTessellator.cpp
@@ -55,7 +55,7 @@
 }
 
 static bool duplicate_pt(const SkPoint& p0, const SkPoint& p1) {
-    SkScalar distSq = p0.distanceToSqd(p1);
+    SkScalar distSq = SkPointPriv::DistanceToSqd(p0, p1);
     return distSq < kCloseSqd;
 }
 
@@ -149,10 +149,10 @@
     for (int cur = 0; cur < fBisectors.count(); prev = cur, ++cur) {
         fBisectors[cur] = fNorms[cur] + fNorms[prev];
         if (!fBisectors[cur].normalize()) {
-            SkASSERT(SkPoint::kLeft_Side == fSide || SkPoint::kRight_Side == fSide);
-            fBisectors[cur].setOrthog(fNorms[cur], (SkPoint::Side)-fSide);
+            SkASSERT(SkPointPriv::kLeft_Side == fSide || SkPointPriv::kRight_Side == fSide);
+            SkPointPriv::SetOrthog(&fBisectors[cur], fNorms[cur], (SkPointPriv::Side)-fSide);
             SkVector other;
-            other.setOrthog(fNorms[prev], fSide);
+            SkPointPriv::SetOrthog(&other, fNorms[prev], fSide);
             fBisectors[cur] += other;
             SkAssertResult(fBisectors[cur].normalize());
         } else {
@@ -424,14 +424,14 @@
         // Check the cross product of the final trio
         SkScalar cross = SkPoint::CrossProduct(fNorms[0], fNorms.top());
         if (cross > 0.0f) {
-            fSide = SkPoint::kRight_Side;
+            fSide = SkPointPriv::kRight_Side;
         } else {
-            fSide = SkPoint::kLeft_Side;
+            fSide = SkPointPriv::kLeft_Side;
         }
 
         // Make all the normals face outwards rather than along the edge
         for (int cur = 0; cur < fNorms.count(); ++cur) {
-            fNorms[cur].setOrthog(fNorms[cur], fSide);
+            SkPointPriv::SetOrthog(&fNorms[cur], fNorms[cur], fSide);
             SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
         }
 
@@ -443,11 +443,11 @@
             return false;
         }
         // For stroking, we still need to process the degenerate path, so fix it up
-        fSide = SkPoint::kLeft_Side;
+        fSide = SkPointPriv::kLeft_Side;
 
         // Make all the normals face outwards rather than along the edge
         for (int cur = 0; cur < fNorms.count(); ++cur) {
-            fNorms[cur].setOrthog(fNorms[cur], fSide);
+            SkPointPriv::SetOrthog(&fNorms[cur], fNorms[cur], fSide);
             SkASSERT(SkScalarNearlyEqual(1.0f, fNorms[cur].length()));
         }
 
@@ -839,7 +839,7 @@
 
         fPts[cur].fNorm = tess.point(fPts[next].fIndex) - tess.point(fPts[cur].fIndex);
         SkPoint::Normalize(&fPts[cur].fNorm);
-        fPts[cur].fNorm.setOrthog(fPts[cur].fNorm, tess.side());
+        SkPointPriv::SetOrthog(&fPts[cur].fNorm, fPts[cur].fNorm, tess.side());
     }
 }
 
@@ -848,10 +848,12 @@
     for (int cur = 0; cur < fPts.count(); prev = cur, ++cur) {
         fPts[cur].fBisector = fPts[cur].fNorm + fPts[prev].fNorm;
         if (!fPts[cur].fBisector.normalize()) {
-            SkASSERT(SkPoint::kLeft_Side == tess.side() || SkPoint::kRight_Side == tess.side());
-            fPts[cur].fBisector.setOrthog(fPts[cur].fNorm, (SkPoint::Side)-tess.side());
+            SkASSERT(SkPointPriv::kLeft_Side == tess.side() ||
+                     SkPointPriv::kRight_Side == tess.side());
+            SkPointPriv::SetOrthog(&fPts[cur].fBisector, fPts[cur].fNorm,
+                                   (SkPointPriv::Side)-tess.side());
             SkVector other;
-            other.setOrthog(fPts[prev].fNorm, tess.side());
+            SkPointPriv::SetOrthog(&other, fPts[prev].fNorm, tess.side());
             fPts[cur].fBisector += other;
             SkAssertResult(fPts[cur].fBisector.normalize());
         } else {
diff --git a/src/gpu/ops/GrAAConvexTessellator.h b/src/gpu/ops/GrAAConvexTessellator.h
index ee91128..caf4905 100644
--- a/src/gpu/ops/GrAAConvexTessellator.h
+++ b/src/gpu/ops/GrAAConvexTessellator.h
@@ -10,7 +10,7 @@
 
 #include "SkColor.h"
 #include "SkPaint.h"
-#include "SkPoint.h"
+#include "SkPointPriv.h"
 #include "SkScalar.h"
 #include "SkStrokeRec.h"
 #include "SkTDArray.h"
@@ -36,14 +36,14 @@
                           SkScalar strokeWidth = -1.0f,
                           SkPaint::Join join = SkPaint::Join::kBevel_Join,
                           SkScalar miterLimit = 0.0f)
-        : fSide(SkPoint::kOn_Side)
+        : fSide(SkPointPriv::kOn_Side)
         , fStrokeWidth(strokeWidth)
         , fStyle(style)
         , fJoin(join)
         , fMiterLimit(miterLimit) {
     }
 
-    SkPoint::Side side() const { return fSide; }
+    SkPointPriv::Side side() const { return fSide; }
 
     bool tessellate(const SkMatrix& m, const SkPath& path);
 
@@ -262,7 +262,7 @@
     // needed for exterior ring creation and then handed off to the initial ring.
     SkTDArray<SkVector>   fBisectors;
 
-    SkPoint::Side         fSide;    // winding of the original polygon
+    SkPointPriv::Side     fSide;    // winding of the original polygon
 
     // The triangulation of the points
     SkTDArray<int>        fIndices;
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index 6dd5dc0..efab0d7 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -19,6 +19,7 @@
 #include "GrSimpleMeshDrawOpHelper.h"
 #include "SkGeometry.h"
 #include "SkPoint3.h"
+#include "SkPointPriv.h"
 #include "SkStroke.h"
 #include "SkTemplates.h"
 #include "effects/GrBezierEffect.h"
@@ -176,17 +177,17 @@
     static const SkScalar gDegenerateToLineTolSqd =
         gDegenerateToLineTol * gDegenerateToLineTol;
 
-    if (p[0].distanceToSqd(p[1]) < gDegenerateToLineTolSqd ||
-        p[1].distanceToSqd(p[2]) < gDegenerateToLineTolSqd) {
+    if (SkPointPriv::DistanceToSqd(p[0], p[1]) < gDegenerateToLineTolSqd ||
+        SkPointPriv::DistanceToSqd(p[1], p[2]) < gDegenerateToLineTolSqd) {
         return 1;
     }
 
-    *dsqd = p[1].distanceToLineBetweenSqd(p[0], p[2]);
+    *dsqd = SkPointPriv::DistanceToLineBetweenSqd(p[1], p[0], p[2]);
     if (*dsqd < gDegenerateToLineTolSqd) {
         return 1;
     }
 
-    if (p[2].distanceToLineBetweenSqd(p[1], p[0]) < gDegenerateToLineTolSqd) {
+    if (SkPointPriv::DistanceToLineBetweenSqd(p[2], p[1], p[0]) < gDegenerateToLineTolSqd) {
         return 1;
     }
     return 0;
@@ -555,14 +556,14 @@
 
     ab.normalize();
     SkVector abN;
-    abN.setOrthog(ab, SkVector::kLeft_Side);
+    SkPointPriv::SetOrthog(&abN, ab, SkPointPriv::kLeft_Side);
     if (abN.dot(ac) > 0) {
         abN.negate();
     }
 
     cb.normalize();
     SkVector cbN;
-    cbN.setOrthog(cb, SkVector::kLeft_Side);
+    SkPointPriv::SetOrthog(&cbN, cb, SkPointPriv::kLeft_Side);
     if (cbN.dot(ac) < 0) {
         cbN.negate();
     }
@@ -641,7 +642,7 @@
     SkVector ortho, vec = b;
     vec -= a;
 
-    SkScalar lengthSqd = vec.lengthSqd();
+    SkScalar lengthSqd = SkPointPriv::LengthSqd(vec);
 
     if (vec.setLength(SK_ScalarHalf)) {
         // Create a vector orthogonal to 'vec' and of unit length
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 82b2012..e87a335 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -17,6 +17,7 @@
 #include "GrProcessor.h"
 #include "GrStyle.h"
 #include "SkGr.h"
+#include "SkPointPriv.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
@@ -92,7 +93,7 @@
     vecSrc.scale(invSrc);
 
     SkVector vecSrcPerp;
-    vecSrc.rotateCW(&vecSrcPerp);
+    SkPointPriv::RotateCW(vecSrc, &vecSrcPerp);
     viewMatrix.mapVectors(&vecSrc, 1);
     viewMatrix.mapVectors(&vecSrcPerp, 1);
 
diff --git a/src/gpu/text/GrStencilAndCoverTextContext.cpp b/src/gpu/text/GrStencilAndCoverTextContext.cpp
index b072702..86e5732 100644
--- a/src/gpu/text/GrStencilAndCoverTextContext.cpp
+++ b/src/gpu/text/GrStencilAndCoverTextContext.cpp
@@ -20,6 +20,7 @@
 #include "SkGlyphCache.h"
 #include "SkGr.h"
 #include "SkPath.h"
+#include "SkPointPriv.h"
 #include "SkTextBlobRunIterator.h"
 #include "SkTextFormatParams.h"
 #include "SkTextMapStateProc.h"
@@ -671,7 +672,7 @@
     // This will automatically merge with previous runs since we use the same font.
     const SkTextBlobBuilder::RunBuffer& buff = fBuilder->allocRunPos(fFont, fBuffIdx);
     memcpy(buff.glyphs, fGlyphIds, fBuffIdx * sizeof(uint16_t));
-    memcpy(buff.pos, fPositions[0].asScalars(), fBuffIdx * 2 * sizeof(SkScalar));
+    memcpy(buff.pos, SkPointPriv::AsScalars(fPositions[0]), fBuffIdx * 2 * sizeof(SkScalar));
     fBuffIdx = 0;
 }
 
diff --git a/src/pathops/SkOpSegment.cpp b/src/pathops/SkOpSegment.cpp
index 402f666..451a155 100644
--- a/src/pathops/SkOpSegment.cpp
+++ b/src/pathops/SkOpSegment.cpp
@@ -8,6 +8,7 @@
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
+#include "SkPointPriv.h"
 
 /*
 After computing raw intersections, post process all segments to:
@@ -1351,7 +1352,7 @@
                     goto nextRef;
                 }
             }
-            SkScalar distSq = ref->fPt.distanceToSqd(check->fPt);
+            SkScalar distSq = SkPointPriv::DistanceToSqd(ref->fPt, check->fPt);
             if (distSqBest > distSq && (refSeg != check->segment()
                     || !refSeg->ptsDisjoint(*ref, *check))) {
                 distSqBest = distSq;
@@ -1448,8 +1449,9 @@
     // on the other hand, the below check is relatively inexpensive
     double midT = (t1 + t2) / 2;
     SkPoint midPt = this->ptAtT(midT);
-    double seDistSq = SkTMax(pt1.distanceToSqd(pt2) * 2, FLT_EPSILON * 2);
-    return midPt.distanceToSqd(pt1) > seDistSq || midPt.distanceToSqd(pt2) > seDistSq;
+    double seDistSq = SkTMax(SkPointPriv::DistanceToSqd(pt1, pt2) * 2, FLT_EPSILON * 2);
+    return SkPointPriv::DistanceToSqd(midPt, pt1) > seDistSq ||
+           SkPointPriv::DistanceToSqd(midPt, pt2) > seDistSq;
 }
 
 void SkOpSegment::setUpWindings(SkOpSpanBase* start, SkOpSpanBase* end, int* sumMiWinding,
diff --git a/src/utils/SkDashPath.cpp b/src/utils/SkDashPath.cpp
index 4b5e58e..d3c52da 100644
--- a/src/utils/SkDashPath.cpp
+++ b/src/utils/SkDashPath.cpp
@@ -7,6 +7,7 @@
 
 #include "SkDashPathPriv.h"
 #include "SkPathMeasure.h"
+#include "SkPointPriv.h"
 #include "SkStrokeRec.h"
 
 static inline int is_even(int x) {
@@ -166,7 +167,7 @@
 
         fPathLength = pathLength;
         fTangent.scale(SkScalarInvert(pathLength));
-        fTangent.rotateCCW(&fNormal);
+        SkPointPriv::RotateCCW(fTangent, &fNormal);
         fNormal.scale(SkScalarHalf(rec->getWidth()));
 
         // now estimate how many quads will be added to the path
diff --git a/src/utils/SkInsetConvexPolygon.cpp b/src/utils/SkInsetConvexPolygon.cpp
index fc40c8e..8a55b13 100755
--- a/src/utils/SkInsetConvexPolygon.cpp
+++ b/src/utils/SkInsetConvexPolygon.cpp
@@ -7,6 +7,7 @@
 
 #include "SkInsetConvexPolygon.h"
 
+#include "SkPointPriv.h"
 #include "SkTemplates.h"
 
 struct InsetSegment {
@@ -67,7 +68,7 @@
         }
         SkScalar dD = d0 - d1;
         // if one circle is inside another, we can't compute an offset
-        if (dD*dD >= p0.distanceToSqd(p1)) {
+        if (dD*dD >= SkPointPriv::DistanceToSqd(p0, p1)) {
             return false;
         }
         SkPoint outerTangentIntersect = SkPoint::Make((p1.fX*d0 - p0.fX*d1) / dD,
@@ -75,14 +76,14 @@
 
         SkScalar d0sq = d0*d0;
         SkVector dP = outerTangentIntersect - p0;
-        SkScalar dPlenSq = dP.lengthSqd();
+        SkScalar dPlenSq = SkPointPriv::LengthSqd(dP);
         SkScalar discrim = SkScalarSqrt(dPlenSq - d0sq);
         offset0->fX = p0.fX + (d0sq*dP.fX - side*d0*dP.fY*discrim) / dPlenSq;
         offset0->fY = p0.fY + (d0sq*dP.fY + side*d0*dP.fX*discrim) / dPlenSq;
 
         SkScalar d1sq = d1*d1;
         dP = outerTangentIntersect - p1;
-        dPlenSq = dP.lengthSqd();
+        dPlenSq = SkPointPriv::LengthSqd(dP);
         discrim = SkScalarSqrt(dPlenSq - d1sq);
         offset1->fX = p1.fX + (d1sq*dP.fX - side*d1*dP.fY*discrim) / dPlenSq;
         offset1->fY = p1.fY + (d1sq*dP.fY + side*d1*dP.fX*discrim) / dPlenSq;
@@ -103,13 +104,13 @@
     if (SkScalarNearlyZero(perpDot)) {
         // segments are parallel
         // check if endpoints are touching
-        if (s0.fP1.equalsWithinTolerance(s1.fP0)) {
+        if (SkPointPriv::EqualsWithinTolerance(s0.fP1, s1.fP0)) {
             *p = s0.fP1;
             *s = SK_Scalar1;
             *t = 0;
             return true;
         }
-        if (s1.fP1.equalsWithinTolerance(s0.fP0)) {
+        if (SkPointPriv::EqualsWithinTolerance(s1.fP1, s0.fP0)) {
             *p = s1.fP1;
             *s = 0;
             *t = SK_Scalar1;
@@ -233,7 +234,8 @@
                 prevIndex = (prevIndex + inputPolygonSize - 1) % inputPolygonSize;
             // we've already considered this intersection, we're done
             } else if (edgeData[currIndex].fTValue > SK_ScalarMin &&
-                       intersection.equalsWithinTolerance(edgeData[currIndex].fIntersection,
+                       SkPointPriv::EqualsWithinTolerance(intersection,
+                                                          edgeData[currIndex].fIntersection,
                                                           1.0e-6f)) {
                 break;
             } else {
@@ -276,16 +278,17 @@
     currIndex = -1;
     for (int i = 0; i < inputPolygonSize; ++i) {
         if (edgeData[i].fValid && (currIndex == -1 ||
-            !edgeData[i].fIntersection.equalsWithinTolerance((*insetPolygon)[currIndex],
-                                                             kCleanupTolerance))) {
+            !SkPointPriv::EqualsWithinTolerance(edgeData[i].fIntersection,
+                                                (*insetPolygon)[currIndex],
+                                                kCleanupTolerance))) {
             *insetPolygon->push() = edgeData[i].fIntersection;
             currIndex++;
         }
     }
     // make sure the first and last points aren't coincident
     if (currIndex >= 1 &&
-        (*insetPolygon)[0].equalsWithinTolerance((*insetPolygon)[currIndex],
-                                                 kCleanupTolerance)) {
+       SkPointPriv::EqualsWithinTolerance((*insetPolygon)[0], (*insetPolygon)[currIndex],
+                                          kCleanupTolerance)) {
         insetPolygon->pop();
     }
 
diff --git a/src/utils/SkShadowTessellator.cpp b/src/utils/SkShadowTessellator.cpp
index aff59bf..1a71407 100755
--- a/src/utils/SkShadowTessellator.cpp
+++ b/src/utils/SkShadowTessellator.cpp
@@ -12,6 +12,7 @@
 #include "SkInsetConvexPolygon.h"
 #include "SkPath.h"
 #include "SkPoint3.h"
+#include "SkPointPriv.h"
 #include "SkVertices.h"
 
 #if SK_SUPPORT_GPU
@@ -458,7 +459,7 @@
 
         // make sure we don't end up with a sharp alpha edge along the quad diagonal
         if (fColors[fPrevUmbraIndex] != fColors[fFirstVertexIndex] &&
-            fFirstPoint.distanceToSqd(fPositions[fPrevUmbraIndex]) > kMaxEdgeLenSqr) {
+            SkPointPriv::DistanceToSqd(fFirstPoint, fPositions[fPrevUmbraIndex]) > kMaxEdgeLenSqr) {
             SkPoint centerPoint = fPositions[fPrevUmbraIndex] + fPositions[fFirstVertexIndex];
             centerPoint *= 0.5f;
             *fPositions.push() = centerPoint;
@@ -642,7 +643,7 @@
 
     // Split the edge to make sure we don't end up with a sharp alpha edge along the quad diagonal
     if (fColors[fPrevUmbraIndex] != fUmbraColor &&
-        nextPoint.distanceToSqd(fPositions[fPrevUmbraIndex]) > kMaxEdgeLenSqr) {
+        SkPointPriv::DistanceToSqd(nextPoint, fPositions[fPrevUmbraIndex]) > kMaxEdgeLenSqr) {
 
         // This is lacking 1/4 of the next inset -- we'll add it the next time we call addEdge()
         SkPoint centerPoint = fPositions[fPrevUmbraIndex] + umbraPoint;
@@ -847,8 +848,8 @@
     }
 
     // check to see if umbra collapses
-    SkScalar minDistSq = fCentroid.distanceToLineSegmentBetweenSqd(fPathPolygon[0],
-                                                                   fPathPolygon[1]);
+    SkScalar minDistSq = SkPointPriv::DistanceToLineSegmentBetweenSqd(fCentroid, fPathPolygon[0],
+                                                                      fPathPolygon[1]);
     SkRect bounds;
     bounds.setBounds(&fPathPolygon[0], fPathPolygon.count());
     for (int i = 1; i < fPathPolygon.count(); ++i) {
@@ -858,7 +859,8 @@
         }
         SkPoint currPoint = fPathPolygon[i];
         SkPoint nextPoint = fPathPolygon[j];
-        SkScalar distSq = fCentroid.distanceToLineSegmentBetweenSqd(currPoint, nextPoint);
+        SkScalar distSq = SkPointPriv::DistanceToLineSegmentBetweenSqd(fCentroid, currPoint,
+                                                                       nextPoint);
         if (distSq < minDistSq) {
             minDistSq = distSq;
         }
@@ -1153,13 +1155,13 @@
 }
 
 int SkSpotShadowTessellator::getClosestUmbraPoint(const SkPoint& p) {
-    SkScalar minDistance = p.distanceToSqd(fUmbraPolygon[fCurrUmbraPoint]);
+    SkScalar minDistance = SkPointPriv::DistanceToSqd(p, fUmbraPolygon[fCurrUmbraPoint]);
     int index = fCurrUmbraPoint;
     int dir = 1;
     int next = (index + dir) % fUmbraPolygon.count();
 
     // init travel direction
-    SkScalar distance = p.distanceToSqd(fUmbraPolygon[next]);
+    SkScalar distance = SkPointPriv::DistanceToSqd(p, fUmbraPolygon[next]);
     if (distance < minDistance) {
         index = next;
         minDistance = distance;
@@ -1169,12 +1171,12 @@
 
     // iterate until we find a point that increases the distance
     next = (index + dir) % fUmbraPolygon.count();
-    distance = p.distanceToSqd(fUmbraPolygon[next]);
+    distance = SkPointPriv::DistanceToSqd(p, fUmbraPolygon[next]);
     while (distance < minDistance) {
         index = next;
         minDistance = distance;
         next = (index + dir) % fUmbraPolygon.count();
-        distance = p.distanceToSqd(fUmbraPolygon[next]);
+        distance = SkPointPriv::DistanceToSqd(p, fUmbraPolygon[next]);
     }
 
     fCurrUmbraPoint = index;
@@ -1194,7 +1196,7 @@
     static constexpr SkScalar kClose = (SK_Scalar1 / 16);
     static constexpr SkScalar kCloseSqd = kClose*kClose;
 
-    SkScalar distSq = p0.distanceToSqd(p1);
+    SkScalar distSq = SkPointPriv::DistanceToSqd(p0, p1);
     return distSq < kCloseSqd;
 }
 
diff --git a/tests/GeometryTest.cpp b/tests/GeometryTest.cpp
index ad3a6b4..a926501 100644
--- a/tests/GeometryTest.cpp
+++ b/tests/GeometryTest.cpp
@@ -6,8 +6,9 @@
  */
 
 #include "SkGeometry.h"
-#include "Test.h"
+#include "SkPointPriv.h"
 #include "SkRandom.h"
+#include "Test.h"
 #include <array>
 
 static bool nearly_equal(const SkPoint& a, const SkPoint& b) {
@@ -152,7 +153,7 @@
     const int qcount = quadder.countQuads();
     const int pcount = qcount * 2 + 1;
 
-    REPORTER_ASSERT(r, SkPointsAreFinite(qpts, pcount));
+    REPORTER_ASSERT(r, SkPointPriv::AreFinite(qpts, pcount));
 }
 
 /**
diff --git a/tests/PathCoverageTest.cpp b/tests/PathCoverageTest.cpp
index 2551563..ed5ed0e 100644
--- a/tests/PathCoverageTest.cpp
+++ b/tests/PathCoverageTest.cpp
@@ -6,7 +6,7 @@
  */
 
 #include "SkMathPriv.h"
-#include "SkPoint.h"
+#include "SkPointPriv.h"
 #include "SkScalar.h"
 #include "Test.h"
 
@@ -42,7 +42,7 @@
 }
 
 static inline SkScalar compute_distance(const SkPoint points[]) {
-    return points[1].distanceToLineSegmentBetween(points[0], points[2]);
+    return SkPointPriv::DistanceToLineSegmentBetween(points[1], points[0], points[2]);
 }
 
 static inline uint32_t estimate_pointCount(int distance) {
diff --git a/tests/PointTest.cpp b/tests/PointTest.cpp
index c0d1f26..76ac3a1 100644
--- a/tests/PointTest.cpp
+++ b/tests/PointTest.cpp
@@ -6,7 +6,7 @@
  */
 // Unit tests for src/core/SkPoint.cpp and its header
 
-#include "SkPoint.h"
+#include "SkPointPriv.h"
 #include "SkRect.h"
 #include "Test.h"
 
@@ -17,7 +17,7 @@
     const SkScalar* pPtr = SkTCast<const SkScalar*>(&p);
     const SkScalar* rPtr = SkTCast<const SkScalar*>(&r);
 
-    REPORTER_ASSERT(reporter, p.asScalars() == pPtr);
+    REPORTER_ASSERT(reporter, SkPointPriv::AsScalars(p) == pPtr);
     REPORTER_ASSERT(reporter, r.asScalars() == rPtr);
 }
 
@@ -146,7 +146,7 @@
         SkPoint slow = kOne, fast = kOne;
 
         slow.setLength(tests[i]);
-        fast.setLengthFast(tests[i]);
+        SkPointPriv::SetLengthFast(&fast, tests[i]);
 
         if (slow.length() < FLT_MIN && fast.length() < FLT_MIN) continue;
 
diff --git a/tests/RoundRectTest.cpp b/tests/RoundRectTest.cpp
index d9b7a9a..2e31cf1 100644
--- a/tests/RoundRectTest.cpp
+++ b/tests/RoundRectTest.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SkMatrix.h"
+#include "SkPointPriv.h"
 #include "SkRRect.h"
 #include "Test.h"
 
@@ -197,7 +198,8 @@
 
     for (int i = 0; i < 4; ++i) {
         REPORTER_ASSERT(reporter,
-                        rr2.radii((SkRRect::Corner) i).equalsWithinTolerance(halfPoint));
+                        SkPointPriv::EqualsWithinTolerance(rr2.radii((SkRRect::Corner) i),
+                        halfPoint));
     }
     SkRRect rr2_2;  // construct the same RR using the most general set function
     SkVector rr2_2_radii[4] = { { halfPoint.fX, halfPoint.fY }, { halfPoint.fX, halfPoint.fY },
diff --git a/tests/StrokerTest.cpp b/tests/StrokerTest.cpp
index aa6435f..1ccb518 100644
--- a/tests/StrokerTest.cpp
+++ b/tests/StrokerTest.cpp
@@ -11,6 +11,7 @@
 #include "SkPathOpsCubic.h"
 #include "SkPaint.h"
 #include "SkPath.h"
+#include "SkPointPriv.h"
 #include "SkRandom.h"
 #include "SkStrokerPriv.h"
 #include "SkTime.h"
@@ -239,12 +240,12 @@
         do {
             quad[1].fX = r.nextRangeF(0, 500);
             quad[1].fY = r.nextRangeF(0, 500);
-        } while (quad[0].distanceToSqd(quad[1]) < halfSquared);
+        } while (SkPointPriv::DistanceToSqd(quad[0], quad[1]) < halfSquared);
         do {
             quad[2].fX = r.nextRangeF(0, 500);
             quad[2].fY = r.nextRangeF(0, 500);
-        } while (quad[0].distanceToSqd(quad[2]) < halfSquared
-                || quad[1].distanceToSqd(quad[2]) < halfSquared);
+        } while (SkPointPriv::DistanceToSqd(quad[0], quad[2]) < halfSquared
+                || SkPointPriv::DistanceToSqd(quad[1], quad[2]) < halfSquared);
         path.moveTo(quad[0].fX, quad[0].fY);
         path.quadTo(quad[1].fX, quad[1].fY, quad[2].fX, quad[2].fY);
         p.setStrokeWidth(r.nextRangeF(0, 500));
@@ -291,18 +292,18 @@
         do {
             cubic[1].fX = r.nextRangeF(0, 500);
             cubic[1].fY = r.nextRangeF(0, 500);
-        } while (cubic[0].distanceToSqd(cubic[1]) < halfSquared);
+        } while (SkPointPriv::DistanceToSqd(cubic[0], cubic[1]) < halfSquared);
         do {
             cubic[2].fX = r.nextRangeF(0, 500);
             cubic[2].fY = r.nextRangeF(0, 500);
-        } while (  cubic[0].distanceToSqd(cubic[2]) < halfSquared
-                || cubic[1].distanceToSqd(cubic[2]) < halfSquared);
+        } while (  SkPointPriv::DistanceToSqd(cubic[0], cubic[2]) < halfSquared
+                || SkPointPriv::DistanceToSqd(cubic[1], cubic[2]) < halfSquared);
         do {
             cubic[3].fX = r.nextRangeF(0, 500);
             cubic[3].fY = r.nextRangeF(0, 500);
-        } while (  cubic[0].distanceToSqd(cubic[3]) < halfSquared
-                || cubic[1].distanceToSqd(cubic[3]) < halfSquared
-                || cubic[2].distanceToSqd(cubic[3]) < halfSquared);
+        } while (  SkPointPriv::DistanceToSqd(cubic[0], cubic[3]) < halfSquared
+                || SkPointPriv::DistanceToSqd(cubic[1], cubic[3]) < halfSquared
+                || SkPointPriv::DistanceToSqd(cubic[2], cubic[3]) < halfSquared);
         path.moveTo(cubic[0].fX, cubic[0].fY);
         path.cubicTo(cubic[1].fX, cubic[1].fY, cubic[2].fX, cubic[2].fY, cubic[3].fX, cubic[3].fY);
         p.setStrokeWidth(r.nextRangeF(0, 500));