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>

5 files changed, 40 insertions, 34 deletions

diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 0e37238389..3c84b32df7 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 @@ static void compute_vectors(SegmentArray* segments,
     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 @@ static void compute_vectors(SegmentArray* segments,
         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 @@ static void update_degenerate_test(DegenerateTestData* data, const SkPoint& pt)
             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_line_to_segment(const SkPoint& pt,
 
 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 @@ static void create_vertices(const SegmentArray& segments,
 
             // 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 6c0125a576..9927d98b11 100644
--- a/src/gpu/ops/GrAAConvexTessellator.cpp
+++ b/src/gpu/ops/GrAAConvexTessellator.cpp
@@ -55,7 +55,7 @@ static SkScalar perp_intersect(const SkPoint& p0, const SkPoint& n0,
 }
 
 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 @@ void GrAAConvexTessellator::computeBisectors() {
     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 @@ bool GrAAConvexTessellator::extractFromPath(const SkMatrix& m, const SkPath& pat
         // 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 @@ bool GrAAConvexTessellator::extractFromPath(const SkMatrix& m, const SkPath& pat
             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 @@ void GrAAConvexTessellator::Ring::computeNormals(const GrAAConvexTessellator& te
 
         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 @@ void GrAAConvexTessellator::Ring::computeBisectors(const GrAAConvexTessellator&
     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 ee91128bfb..caf4905939 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 @@ public:
                           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 @@ private:
     // 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 6dd5dc08c1..efab0d708d 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 int is_degen_quad_or_conic(const SkPoint p[3], SkScalar* dsqd) {
     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 @@ static void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
 
     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 @@ static void add_line(const SkPoint p[2],
     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 82b2012587..e87a335af0 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 @@ static void calc_dash_scaling(SkScalar* parallelScale, SkScalar* perpScale,
     vecSrc.scale(invSrc);
 
     SkVector vecSrcPerp;
-    vecSrc.rotateCW(&vecSrcPerp);
+    SkPointPriv::RotateCW(vecSrc, &vecSrcPerp);
     viewMatrix.mapVectors(&vecSrc, 1);
     viewMatrix.mapVectors(&vecSrcPerp, 1);