Style Change: NULL->nullptr

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 90 matching lines @@
     return conic.ptAtT(t);
 }
 
 static SkDPoint dcubic_xy_at_t(const SkPoint a[4], SkScalar , double t) {
     SkDCubic cubic;
     cubic.set(a);
     return cubic.ptAtT(t);
 }
 
 static SkDPoint (* const CurveDPointAtT[])(const SkPoint[], SkScalar , double ) = {
-    NULL,
+    nullptr,
     dline_xy_at_t,
     dquad_xy_at_t,
     dconic_xy_at_t,
     dcubic_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();
 }
 
 static SkPoint fcubic_xy_at_t(const SkPoint a[4], SkScalar weight, double t) {
     return dcubic_xy_at_t(a, weight, t).asSkPoint();
 }
 
 static SkPoint (* const CurvePointAtT[])(const SkPoint[], SkScalar , double ) = {
-    NULL,
+    nullptr,
     fline_xy_at_t,
     fquad_xy_at_t,
     fconic_xy_at_t,
     fcubic_xy_at_t
 };
 
 static SkDVector dline_dxdy_at_t(const SkPoint a[2], SkScalar , double ) {
     SkDLine line;
     line.set(a);
     return line[1] - line[0];
@@ skipping 11 matching lines @@
     return conic.dxdyAtT(t);
 }
 
 static SkDVector dcubic_dxdy_at_t(const SkPoint a[4], SkScalar , double t) {
     SkDCubic cubic;
     cubic.set(a);
     return cubic.dxdyAtT(t);
 }
 
 static SkDVector (* const CurveDSlopeAtT[])(const SkPoint[], SkScalar , double ) = {
-    NULL,
+    nullptr,
     dline_dxdy_at_t,
     dquad_dxdy_at_t,
     dconic_dxdy_at_t,
     dcubic_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();
 }
 
 static SkVector fcubic_dxdy_at_t(const SkPoint a[4], SkScalar weight, double t) {
     return dcubic_dxdy_at_t(a, weight, t).asSkVector();
 }
 
 static SkVector (* const CurveSlopeAtT[])(const SkPoint[], SkScalar , double ) = {
-    NULL,
+    nullptr,
     fline_dxdy_at_t,
     fquad_dxdy_at_t,
     fconic_dxdy_at_t,
     fcubic_dxdy_at_t
 };
 
 static bool line_is_vertical(const SkPoint a[2], SkScalar , double startT, double endT) {
     SkDLine line;
     line.set(a);
     SkDPoint dst[2] = { line.ptAtT(startT), line.ptAtT(endT) };
@@ skipping 16 matching lines @@
 
 static bool cubic_is_vertical(const SkPoint a[4], SkScalar , double startT, double endT) {
     SkDCubic cubic;
     cubic.set(a);
     SkDCubic dst = cubic.subDivide(startT, endT);
     return AlmostEqualUlps(dst[0].fX, dst[1].fX) && AlmostEqualUlps(dst[1].fX, dst[2].fX)
             && AlmostEqualUlps(dst[2].fX, dst[3].fX);
 }
 
 static bool (* const CurveIsVertical[])(const SkPoint[], SkScalar , double , double) = {
-    NULL,
+    nullptr,
     line_is_vertical,
     quad_is_vertical,
     conic_is_vertical,
     cubic_is_vertical
 };
 
 static void line_intersect_ray(const SkPoint a[2], SkScalar , const SkDLine& ray,
         SkIntersections* i) {
     SkDLine line;
     line.set(a);
@@ skipping 16 matching lines @@
 
 static void cubic_intersect_ray(const SkPoint a[4], SkScalar , const SkDLine& ray,
         SkIntersections* i) {
     SkDCubic cubic;
     cubic.set(a);
     i->intersectRay(cubic, ray);
 }
 
 static void (* const CurveIntersectRay[])(const SkPoint[] , SkScalar , const SkDLine& ,
         SkIntersections* ) = {
-    NULL,
+    nullptr,
     line_intersect_ray,
     quad_intersect_ray,
     conic_intersect_ray,
     cubic_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);
@@ skipping 29 matching lines @@
     SkDCubic cubic;
     return cubic.set(a).horizontalIntersect(y, roots);
 }
 
 static int cubic_intercept_v(const SkPoint a[3], SkScalar , SkScalar x, double* roots) {
     SkDCubic cubic;
     return cubic.set(a).verticalIntersect(x, roots);
 }
 
 static int (* const CurveIntercept[])(const SkPoint[] , SkScalar , SkScalar , double* ) = {
-    NULL,
-    NULL,
+    nullptr,
+    nullptr,
     line_intercept_h,
     line_intercept_v,
     quad_intercept_h,
     quad_intercept_v,
     conic_intercept_h,
     conic_intercept_v,
     cubic_intercept_h,
     cubic_intercept_v,
 };
 
 #endif