pathops coincidence and security rewrite

src/pathops/SkPathOpsCurve.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPathOpsCurve_DEFINE
 #define SkPathOpsCurve_DEFINE
 
 #include "SkIntersections.h"
@@ skipping 46 matching lines @@
     const SkDPoint& operator[](int n) const {
         SkASSERT(n >= 0 && n <= SkPathOpsVerbToPoints(fVerb));
         return fCubic[n];
     }
 
     SkDPoint& operator[](int n) {
         SkASSERT(n >= 0 && n <= SkPathOpsVerbToPoints(fVerb));
         return fCubic[n];
     }
 
-    SkDPoint conicTop(const SkPoint curve[3], SkScalar curveWeight, 
+    SkDPoint conicTop(const SkPoint curve[3], SkScalar curveWeight,
                       double s, double e, double* topT);
     SkDPoint cubicTop(const SkPoint curve[4], SkScalar , double s, double e, double* topT);
+    void dump() const;
     void dumpID(int ) const;
     SkDPoint lineTop(const SkPoint[2], SkScalar , double , double , double* topT);
+    double nearPoint(SkPath::Verb verb, const SkDPoint& xy, const SkDPoint& opp) const;
+    void offset(SkPath::Verb verb, const SkDVector& );
     SkDPoint quadTop(const SkPoint curve[3], SkScalar , double s, double e, double* topT);
 
-    void setConicBounds(const SkPoint curve[3], SkScalar curveWeight, 
+    void setConicBounds(const SkPoint curve[3], SkScalar curveWeight,
                         double s, double e, SkPathOpsBounds* );
     void setCubicBounds(const SkPoint curve[4], SkScalar ,
                         double s, double e, SkPathOpsBounds* );
     void setQuadBounds(const SkPoint curve[3], SkScalar ,
                        double s, double e, SkPathOpsBounds*);
 };
 
 
 extern SkDPoint (SkDCurve::* const Top[])(const SkPoint curve[], SkScalar cWeight,
     double tStart, double tEnd, double* topT);
@@ skipping 23 matching lines @@
 }
 
 static SkDPoint (* const CurveDPointAtT[])(const SkPoint[], SkScalar , double ) = {
     nullptr,
     dline_xy_at_t,
     dquad_xy_at_t,
     dconic_xy_at_t,
     dcubic_xy_at_t
 };
 
+static SkDPoint ddline_xy_at_t(const SkDCurve& c, double t) {
+    return c.fLine.ptAtT(t);
+}
+
+static SkDPoint ddquad_xy_at_t(const SkDCurve& c, double t) {
+    return c.fQuad.ptAtT(t);
+}
+
+static SkDPoint ddconic_xy_at_t(const SkDCurve& c, double t) {
+    return c.fConic.ptAtT(t);
+}
+
+static SkDPoint ddcubic_xy_at_t(const SkDCurve& c, double t) {
+    return c.fCubic.ptAtT(t);
+}
+
+static SkDPoint (* const CurveDDPointAtT[])(const SkDCurve& , double ) = {

[herb_g, 2016/07/18 15:13:39]

Space before ","

[caryclark, 2016/07/18 15:55:49]

The Skia style guide https://skia.org/dev/contrib/style doesn't provide any
guidance on this. I prefer the space to remind myself that there is an unnamed
parameter. If the rest of Skia is consistent about this, I should change my
usage in many places.

+    nullptr,
+    ddline_xy_at_t,
+    ddquad_xy_at_t,
+    ddconic_xy_at_t,
+    ddcubic_xy_at_t
+};
+
 static SkPoint fline_xy_at_t(const SkPoint a[2], SkScalar weight, double t) {
     return dline_xy_at_t(a, weight, t).asSkPoint();
 }
 
 static SkPoint fquad_xy_at_t(const SkPoint a[3], SkScalar weight, double t) {
     return dquad_xy_at_t(a, weight, t).asSkPoint();
 }
 
 static SkPoint fconic_xy_at_t(const SkPoint a[3], SkScalar weight, double t) {
     return dconic_xy_at_t(a, weight, t).asSkPoint();
@@ skipping 36 matching lines @@
 }
 
 static SkDVector (* const CurveDSlopeAtT[])(const SkPoint[], SkScalar , double ) = {
     nullptr,
     dline_dxdy_at_t,
     dquad_dxdy_at_t,
     dconic_dxdy_at_t,
     dcubic_dxdy_at_t
 };
 
+static SkDVector ddline_dxdy_at_t(const SkDCurve& c, double ) {
+    return c.fLine.fPts[1] - c.fLine.fPts[0];
+}
+
+static SkDVector ddquad_dxdy_at_t(const SkDCurve& c, double t) {
+    return c.fQuad.dxdyAtT(t);
+}
+
+static SkDVector ddconic_dxdy_at_t(const SkDCurve& c, double t) {
+    return c.fConic.dxdyAtT(t);
+}
+
+static SkDVector ddcubic_dxdy_at_t(const SkDCurve& c, double t) {
+    return c.fCubic.dxdyAtT(t);
+}
+
+static SkDVector (* const CurveDDSlopeAtT[])(const SkDCurve& , double ) = {
+    nullptr,
+    ddline_dxdy_at_t,
+    ddquad_dxdy_at_t,
+    ddconic_dxdy_at_t,
+    ddcubic_dxdy_at_t
+};
+
 static SkVector fline_dxdy_at_t(const SkPoint a[2], SkScalar , double ) {
     return a[1] - a[0];
 }
 
 static SkVector fquad_dxdy_at_t(const SkPoint a[3], SkScalar weight, double t) {
     return dquad_dxdy_at_t(a, weight, t).asSkVector();
 }
 
 static SkVector fconic_dxdy_at_t(const SkPoint a[3], SkScalar weight, double t) {
     return dconic_dxdy_at_t(a, weight, t).asSkVector();
@@ skipping 78 matching lines @@
 
 static void (* const CurveIntersectRay[])(const SkPoint[] , SkScalar , const SkDLine& ,
         SkIntersections* ) = {
     nullptr,
     line_intersect_ray,
     quad_intersect_ray,
     conic_intersect_ray,
     cubic_intersect_ray
 };
 
+static void dline_intersect_ray(const SkDCurve& c, const SkDLine& ray,  SkIntersections* i) {
+    i->intersectRay(c.fLine, ray);
+}
+
+static void dquad_intersect_ray(const SkDCurve& c, const SkDLine& ray, SkIntersections* i) {
+    i->intersectRay(c.fQuad, ray);
+}
+
+static void dconic_intersect_ray(const SkDCurve& c, const SkDLine& ray, SkIntersections* i) {
+    i->intersectRay(c.fConic, ray);
+}
+
+static void dcubic_intersect_ray(const SkDCurve& c, const SkDLine& ray, SkIntersections* i) {
+    i->intersectRay(c.fCubic, ray);
+}
+
+static void (* const CurveDIntersectRay[])(const SkDCurve& , const SkDLine& , SkIntersections* ) = {
+    nullptr,
+    dline_intersect_ray,
+    dquad_intersect_ray,
+    dconic_intersect_ray,
+    dcubic_intersect_ray
+};
+
 static int line_intercept_h(const SkPoint a[2], SkScalar , SkScalar y, double* roots) {
     SkDLine line;
     roots[0] = SkIntersections::HorizontalIntercept(line.set(a), y);
     return between(0, roots[0], 1);
 }
 
 static int line_intercept_v(const SkPoint a[2], SkScalar , SkScalar x, double* roots) {
     SkDLine line;
     roots[0] = SkIntersections::VerticalIntercept(line.set(a), x);
     return between(0, roots[0], 1);
@@ skipping 36 matching lines @@
     line_intercept_v,
     quad_intercept_h,
     quad_intercept_v,
     conic_intercept_h,
     conic_intercept_v,
     cubic_intercept_h,
     cubic_intercept_v,
 };
 
 #endif