Style Change: NULL->nullptr

tests/PathTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkParse.h"
@@ skipping 296 matching lines @@
     path.moveTo(pts[0]);
     path.cubicTo(pts[1], pts[2], pts[3]);
 
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(20);
 
     SkPath dst;
     // Before the fix, this would infinite-recurse, and run out of stack
     // because we would keep trying to subdivide a degenerate cubic segment.
-    paint.getFillPath(path, &dst, NULL);
+    paint.getFillPath(path, &dst, nullptr);
 }
 
 static void build_path_170666(SkPath& path) {
     path.moveTo(17.9459f, 21.6344f);
     path.lineTo(139.545f, -47.8105f);
     path.lineTo(139.545f, -47.8105f);
     path.lineTo(131.07f, -47.3888f);
     path.lineTo(131.07f, -47.3888f);
     path.lineTo(122.586f, -46.9532f);
     path.lineTo(122.586f, -46.9532f);
@@ skipping 150 matching lines @@
         "L-0.33997991989448945,-0.11301535852306784L-0.33990282433493346,-0.11296217481488612"
         "L-0.33993994441916414,-0.11288906492739594Z";
     test_tiny_path_convexity(reporter, originalFiddleData, 22682.240000000005f,7819.72220766405f,
             65536);
 }
 
 static void test_addrect(skiatest::Reporter* reporter) {
     SkPath path;
     path.lineTo(0, 0);
     path.addRect(SkRect::MakeWH(50, 100));
-    REPORTER_ASSERT(reporter, path.isRect(NULL));
+    REPORTER_ASSERT(reporter, path.isRect(nullptr));
 
     path.reset();
     path.lineTo(FLT_EPSILON, FLT_EPSILON);
     path.addRect(SkRect::MakeWH(50, 100));
-    REPORTER_ASSERT(reporter, !path.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path.isRect(nullptr));
 
     path.reset();
     path.quadTo(0, 0, 0, 0);
     path.addRect(SkRect::MakeWH(50, 100));
-    REPORTER_ASSERT(reporter, !path.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path.isRect(nullptr));
 
     path.reset();
     path.conicTo(0, 0, 0, 0, 0.5f);
     path.addRect(SkRect::MakeWH(50, 100));
-    REPORTER_ASSERT(reporter, !path.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path.isRect(nullptr));
 
     path.reset();
     path.cubicTo(0, 0, 0, 0, 0, 0);
     path.addRect(SkRect::MakeWH(50, 100));
-    REPORTER_ASSERT(reporter, !path.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path.isRect(nullptr));
 }
 
 // Make sure we stay non-finite once we get there (unless we reset or rewind).
 static void test_addrect_isfinite(skiatest::Reporter* reporter) {
     SkPath path;
 
     path.addRect(SkRect::MakeWH(50, 100));
     REPORTER_ASSERT(reporter, path.isFinite());
 
     path.moveTo(0, 0);
@@ skipping 400 matching lines @@
     if (SkPathPriv::CheapComputeFirstDirection(copy, &dir)) {
         REPORTER_ASSERT(reporter, dir == expected);
     } else {
         REPORTER_ASSERT(reporter, SkPathPriv::kUnknown_FirstDirection == expected);
     }
 }
 
 static void test_direction(skiatest::Reporter* reporter) {
     size_t i;
     SkPath path;
-    REPORTER_ASSERT(reporter, !SkPathPriv::CheapComputeFirstDirection(path, NULL));
+    REPORTER_ASSERT(reporter, !SkPathPriv::CheapComputeFirstDirection(path, nullptr));
     REPORTER_ASSERT(reporter, !SkPathPriv::CheapIsFirstDirection(path, SkPathPriv::kCW_FirstDirection));
     REPORTER_ASSERT(reporter, !SkPathPriv::CheapIsFirstDirection(path, SkPathPriv::kCCW_FirstDirection));
     REPORTER_ASSERT(reporter, SkPathPriv::CheapIsFirstDirection(path, SkPathPriv::kUnknown_FirstDirection));
 
     static const char* gDegen[] = {
         "M 10 10",
         "M 10 10 M 20 20",
         "M 10 10 L 20 20",
         "M 10 10 L 10 10 L 10 10",
         "M 10 10 Q 10 10 10 10",
         "M 10 10 C 10 10 10 10 10 10",
     };
     for (i = 0; i < SK_ARRAY_COUNT(gDegen); ++i) {
         path.reset();
         bool valid = SkParsePath::FromSVGString(gDegen[i], &path);
         REPORTER_ASSERT(reporter, valid);
-        REPORTER_ASSERT(reporter, !SkPathPriv::CheapComputeFirstDirection(path, NULL));
+        REPORTER_ASSERT(reporter, !SkPathPriv::CheapComputeFirstDirection(path, nullptr));
     }
 
     static const char* gCW[] = {
         "M 10 10 L 10 10 Q 20 10 20 20",
         "M 10 10 C 20 10 20 20 20 20",
         "M 20 10 Q 20 20 30 20 L 10 20", // test double-back at y-max
         // rect with top two corners replaced by cubics with identical middle
         // control points
         "M 10 10 C 10 0 10 0 20 0 L 40 0 C 50 0 50 0 50 10",
         "M 20 10 L 0 10 Q 10 10 20 0",  // left, degenerate serif
@@ skipping 397 matching lines @@
     other.swap(p2);
     REPORTER_ASSERT(reporter, other.isConvex());
     REPORTER_ASSERT(reporter, other.getBounds() == bounds);
 }
 
 static void setFromString(SkPath* path, const char str[]) {
     bool first = true;
     while (str) {
         SkScalar x, y;
         str = SkParse::FindScalar(str, &x);
-        if (NULL == str) {
+        if (nullptr == str) {
             break;
         }
         str = SkParse::FindScalar(str, &y);
         SkASSERT(str);
         if (first) {
             path->moveTo(x, y);
             first = false;
         } else {
             path->lineTo(x, y);
         }
@@ skipping 125 matching lines @@
                 : SkPath::kUnknown_Convexity);
     }
 
 }
 
 static void test_isLine(skiatest::Reporter* reporter) {
     SkPath path;
     SkPoint pts[2];
     const SkScalar value = SkIntToScalar(5);
 
-    REPORTER_ASSERT(reporter, !path.isLine(NULL));
+    REPORTER_ASSERT(reporter, !path.isLine(nullptr));
 
     // set some non-zero values
     pts[0].set(value, value);
     pts[1].set(value, value);
     REPORTER_ASSERT(reporter, !path.isLine(pts));
     // check that pts was untouched
     REPORTER_ASSERT(reporter, pts[0].equals(value, value));
     REPORTER_ASSERT(reporter, pts[1].equals(value, value));
 
     const SkScalar moveX = SkIntToScalar(1);
     const SkScalar moveY = SkIntToScalar(2);
     REPORTER_ASSERT(reporter, value != moveX && value != moveY);
 
     path.moveTo(moveX, moveY);
-    REPORTER_ASSERT(reporter, !path.isLine(NULL));
+    REPORTER_ASSERT(reporter, !path.isLine(nullptr));
     REPORTER_ASSERT(reporter, !path.isLine(pts));
     // check that pts was untouched
     REPORTER_ASSERT(reporter, pts[0].equals(value, value));
     REPORTER_ASSERT(reporter, pts[1].equals(value, value));
 
     const SkScalar lineX = SkIntToScalar(2);
     const SkScalar lineY = SkIntToScalar(2);
     REPORTER_ASSERT(reporter, value != lineX && value != lineY);
 
     path.lineTo(lineX, lineY);
-    REPORTER_ASSERT(reporter, path.isLine(NULL));
+    REPORTER_ASSERT(reporter, path.isLine(nullptr));
 
     REPORTER_ASSERT(reporter, !pts[0].equals(moveX, moveY));
     REPORTER_ASSERT(reporter, !pts[1].equals(lineX, lineY));
     REPORTER_ASSERT(reporter, path.isLine(pts));
     REPORTER_ASSERT(reporter, pts[0].equals(moveX, moveY));
     REPORTER_ASSERT(reporter, pts[1].equals(lineX, lineY));
 
     path.lineTo(0, 0);  // too many points/verbs
-    REPORTER_ASSERT(reporter, !path.isLine(NULL));
+    REPORTER_ASSERT(reporter, !path.isLine(nullptr));
     REPORTER_ASSERT(reporter, !path.isLine(pts));
     REPORTER_ASSERT(reporter, pts[0].equals(moveX, moveY));
     REPORTER_ASSERT(reporter, pts[1].equals(lineX, lineY));
 
     path.reset();
     path.quadTo(1, 1, 2, 2);
-    REPORTER_ASSERT(reporter, !path.isLine(NULL));
+    REPORTER_ASSERT(reporter, !path.isLine(nullptr));
 }
 
 static void test_conservativelyContains(skiatest::Reporter* reporter) {
     SkPath path;
 
     // kBaseRect is used to construct most our test paths: a rect, a circle, and a round-rect.
     static const SkRect kBaseRect = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(100));
 
     // A circle that bounds kBaseRect (with a significant amount of slop)
     SkScalar circleR = SkMaxScalar(kBaseRect.width(), kBaseRect.height());
@@ skipping 201 matching lines @@
     REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(SkRect::MakeXYWH(0, 0, 1, 1)));
 }
 
 static void test_isRect_open_close(skiatest::Reporter* reporter) {
     SkPath path;
     bool isClosed;
 
     path.moveTo(0, 0); path.lineTo(1, 0); path.lineTo(1, 1); path.lineTo(0, 1);
     path.close();
 
-    REPORTER_ASSERT(reporter, path.isRect(NULL, &isClosed, NULL));
+    REPORTER_ASSERT(reporter, path.isRect(nullptr, &isClosed, nullptr));
     REPORTER_ASSERT(reporter, isClosed);
 }
 
 // Simple isRect test is inline TestPath, below.
 // test_isRect provides more extensive testing.
 static void test_isRect(skiatest::Reporter* reporter) {
     test_isRect_open_close(reporter);
 
     // passing tests (all moveTo / lineTo...
     SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
@@ skipping 83 matching lines @@
     int index;
     for (size_t testIndex = 0; testIndex < testCount; ++testIndex) {
         SkPath path;
         path.moveTo(tests[testIndex].fPoints[0].fX, tests[testIndex].fPoints[0].fY);
         for (index = 1; index < tests[testIndex].fPointCount; ++index) {
             path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
         }
         if (tests[testIndex].fClose) {
             path.close();
         }
-        REPORTER_ASSERT(reporter, tests[testIndex].fIsRect == path.isRect(NULL));
+        REPORTER_ASSERT(reporter, tests[testIndex].fIsRect == path.isRect(nullptr));
 
         if (tests[testIndex].fIsRect) {
             SkRect computed, expected;
             bool isClosed;
             SkPath::Direction direction;
             SkPathPriv::FirstDirection cheapDirection;
             expected.set(tests[testIndex].fPoints, tests[testIndex].fPointCount);
             REPORTER_ASSERT(reporter, SkPathPriv::CheapComputeFirstDirection(path, &cheapDirection));
             REPORTER_ASSERT(reporter, path.isRect(&computed, &isClosed, &direction));
             REPORTER_ASSERT(reporter, expected == computed);
@@ skipping 13 matching lines @@
     }
 
     // fail, close then line
     SkPath path1;
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     path1.lineTo(1, 0);
-    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path1.isRect(nullptr));
 
     // fail, move in the middle
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
         if (index == 2) {
             path1.moveTo(1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path1.isRect(nullptr));
 
     // fail, move on the edge
     path1.reset();
     for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
         path1.moveTo(r1[index - 1].fX, r1[index - 1].fY);
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path1.isRect(nullptr));
 
     // fail, quad
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
         if (index == 2) {
             path1.quadTo(1, .5f, 1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path1.isRect(nullptr));
 
     // fail, cubic
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
         if (index == 2) {
             path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
-    REPORTER_ASSERT(reporter, !path1.isRect(NULL));
+    REPORTER_ASSERT(reporter, !path1.isRect(nullptr));
 }
 
 static void test_isNestedFillRects(skiatest::Reporter* reporter) {
     // passing tests (all moveTo / lineTo...
     SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
     SkPoint r2[] = {{1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint r3[] = {{1, 1}, {0, 1}, {0, 0}, {1, 0}};
     SkPoint r4[] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
     SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}}; // CCW
     SkPoint r6[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
@@ skipping 67 matching lines @@
             for (index = 1; index < tests[testIndex].fPointCount; ++index) {
                 path.lineTo(tests[testIndex].fPoints[index].fX, tests[testIndex].fPoints[index].fY);
             }
             if (tests[testIndex].fClose) {
                 path.close();
             }
             if (!rectFirst) {
                 path.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
             }
             REPORTER_ASSERT(reporter,
-                    tests[testIndex].fIsNestedRect == path.isNestedFillRects(NULL));
+                    tests[testIndex].fIsNestedRect == path.isNestedFillRects(nullptr));
             if (tests[testIndex].fIsNestedRect) {
                 SkRect expected[2], computed[2];
                 SkPathPriv::FirstDirection expectedDirs[2];
                 SkPath::Direction computedDirs[2];
                 SkRect testBounds;
                 testBounds.set(tests[testIndex].fPoints, tests[testIndex].fPointCount);
                 expected[0] = SkRect::MakeLTRB(-1, -1, 2, 2);
                 expected[1] = testBounds;
                 if (rectFirst) {
                     expectedDirs[0] = SkPathPriv::kCW_FirstDirection;
@@ skipping 16 matching lines @@
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         path1.lineTo(1, 0);
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(NULL));
+        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
 
         // fail, move in the middle
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
             if (index == 2) {
                 path1.moveTo(1, .5f);
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(NULL));
+        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
 
         // fail, move on the edge
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
             path1.moveTo(r1[index - 1].fX, r1[index - 1].fY);
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(NULL));
+        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
 
         // fail, quad
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
             if (index == 2) {
                 path1.quadTo(1, .5f, 1, .5f);
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(NULL));
+        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
 
         // fail, cubic
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SkToInt(SK_ARRAY_COUNT(r1)); ++index) {
             if (index == 2) {
                 path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
-        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(NULL));
+        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
 
         // fail,  not nested
         path1.reset();
         path1.addRect(1, 1, 3, 3, SkPath::kCW_Direction);
         path1.addRect(2, 2, 4, 4, SkPath::kCW_Direction);
-        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(NULL));
+        REPORTER_ASSERT(reporter, !path1.isNestedFillRects(nullptr));
     }
 
     //  pass, constructed explicitly from manually closed rects specified as moves/lines.
     SkPath path;
     path.moveTo(0, 0);
     path.lineTo(10, 0);
     path.lineTo(10, 10);
     path.lineTo(0, 10);
     path.lineTo(0, 0);
     path.moveTo(1, 1);
     path.lineTo(9, 1);
     path.lineTo(9, 9);
     path.lineTo(1, 9);
     path.lineTo(1, 1);
-    REPORTER_ASSERT(reporter, path.isNestedFillRects(NULL));
+    REPORTER_ASSERT(reporter, path.isNestedFillRects(nullptr));
 
     // pass, stroke rect
     SkPath src, dst;
     src.addRect(1, 1, 7, 7, SkPath::kCW_Direction);
     SkPaint strokePaint;
     strokePaint.setStyle(SkPaint::kStroke_Style);
     strokePaint.setStrokeWidth(2);
     strokePaint.getFillPath(src, &dst);
-    REPORTER_ASSERT(reporter, dst.isNestedFillRects(NULL));
+    REPORTER_ASSERT(reporter, dst.isNestedFillRects(nullptr));
 }
 
 static void write_and_read_back(skiatest::Reporter* reporter,
                                 const SkPath& p) {
     SkWriter32 writer;
     writer.writePath(p);
     size_t size = writer.bytesWritten();
     SkAutoMalloc storage(size);
     writer.flatten(storage.get());
     SkReader32 reader(storage.get(), size);
 
     SkPath readBack;
     REPORTER_ASSERT(reporter, readBack != p);
     reader.readPath(&readBack);
     REPORTER_ASSERT(reporter, readBack == p);
 
     REPORTER_ASSERT(reporter, readBack.getConvexityOrUnknown() ==
                               p.getConvexityOrUnknown());
 
-    REPORTER_ASSERT(reporter, readBack.isOval(NULL) == p.isOval(NULL));
+    REPORTER_ASSERT(reporter, readBack.isOval(nullptr) == p.isOval(nullptr));
 
     const SkRect& origBounds = p.getBounds();
     const SkRect& readBackBounds = readBack.getBounds();
 
     REPORTER_ASSERT(reporter, origBounds == readBackBounds);
 }
 
 static void test_flattening(skiatest::Reporter* reporter) {
     SkPath p;
 
     static const SkPoint pts[] = {
         { 0, 0 },
         { SkIntToScalar(10), SkIntToScalar(10) },
         { SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 },
         { 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) }
     };
     p.moveTo(pts[0]);
     p.lineTo(pts[1]);
     p.quadTo(pts[2], pts[3]);
     p.cubicTo(pts[4], pts[5], pts[6]);
 
     write_and_read_back(reporter, p);
 
     // create a buffer that should be much larger than the path so we don't
     // kill our stack if writer goes too far.
     char buffer[1024];
-    size_t size1 = p.writeToMemory(NULL);
+    size_t size1 = p.writeToMemory(nullptr);
     size_t size2 = p.writeToMemory(buffer);
     REPORTER_ASSERT(reporter, size1 == size2);
 
     SkPath p2;
     size_t size3 = p2.readFromMemory(buffer, 1024);
     REPORTER_ASSERT(reporter, size1 == size3);
     REPORTER_ASSERT(reporter, p == p2);
 
     size3 = p2.readFromMemory(buffer, 0);
     REPORTER_ASSERT(reporter, !size3);
@@ skipping 69 matching lines @@
     {
         SkMatrix matrix;
         matrix.reset();
         matrix.setPerspX(4);
 
         SkPath p1;
         p1.moveTo(SkPoint::Make(0, 0));
 
         p.transform(matrix, &p1);
         REPORTER_ASSERT(reporter, matrix.invert(&matrix));
-        p1.transform(matrix, NULL);
+        p1.transform(matrix, nullptr);
         SkRect pBounds = p.getBounds();
         SkRect p1Bounds = p1.getBounds();
         REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fLeft, p1Bounds.fLeft));
         REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fTop, p1Bounds.fTop));
         REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fRight, p1Bounds.fRight));
         REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fBottom, p1Bounds.fBottom));
     }
 
     p.reset();
     p.addCircle(0, 0, 1, SkPath::kCW_Direction);
@@ skipping 753 matching lines @@
 }
 
 static void test_oval(skiatest::Reporter* reporter) {
     SkRect rect;
     SkMatrix m;
     SkPath path;
 
     rect = SkRect::MakeWH(SkIntToScalar(30), SkIntToScalar(50));
     path.addOval(rect);
 
-    REPORTER_ASSERT(reporter, path.isOval(NULL));
+    REPORTER_ASSERT(reporter, path.isOval(nullptr));
 
     m.setRotate(SkIntToScalar(90));
     SkPath tmp;
     path.transform(m, &tmp);
     // an oval rotated 90 degrees is still an oval.
-    REPORTER_ASSERT(reporter, tmp.isOval(NULL));
+    REPORTER_ASSERT(reporter, tmp.isOval(nullptr));
 
     m.reset();
     m.setRotate(SkIntToScalar(30));
     tmp.reset();
     path.transform(m, &tmp);
     // an oval rotated 30 degrees is not an oval anymore.
-    REPORTER_ASSERT(reporter, !tmp.isOval(NULL));
+    REPORTER_ASSERT(reporter, !tmp.isOval(nullptr));
 
     // since empty path being transformed.
     path.reset();
     tmp.reset();
     m.reset();
     path.transform(m, &tmp);
-    REPORTER_ASSERT(reporter, !tmp.isOval(NULL));
+    REPORTER_ASSERT(reporter, !tmp.isOval(nullptr));
 
     // empty path is not an oval
     tmp.reset();
-    REPORTER_ASSERT(reporter, !tmp.isOval(NULL));
+    REPORTER_ASSERT(reporter, !tmp.isOval(nullptr));
 
     // only has moveTo()s
     tmp.reset();
     tmp.moveTo(0, 0);
     tmp.moveTo(SkIntToScalar(10), SkIntToScalar(10));
-    REPORTER_ASSERT(reporter, !tmp.isOval(NULL));
+    REPORTER_ASSERT(reporter, !tmp.isOval(nullptr));
 
     // mimic WebKit's calling convention,
     // call moveTo() first and then call addOval()
     path.reset();
     path.moveTo(0, 0);
     path.addOval(rect);
-    REPORTER_ASSERT(reporter, path.isOval(NULL));
+    REPORTER_ASSERT(reporter, path.isOval(nullptr));
 
     // copy path
     path.reset();
     tmp.reset();
     tmp.addOval(rect);
     path = tmp;
-    REPORTER_ASSERT(reporter, path.isOval(NULL));
+    REPORTER_ASSERT(reporter, path.isOval(nullptr));
 }
 
 static void test_empty(skiatest::Reporter* reporter, const SkPath& p) {
     SkPath  empty;
 
     REPORTER_ASSERT(reporter, p.isEmpty());
     REPORTER_ASSERT(reporter, 0 == p.countPoints());
     REPORTER_ASSERT(reporter, 0 == p.countVerbs());
     REPORTER_ASSERT(reporter, 0 == p.getSegmentMasks());
     REPORTER_ASSERT(reporter, p.isConvex());
@@ skipping 50 matching lines @@
     p.addRoundRect(r, 0, 0);
     SkRect returnedRect;
     REPORTER_ASSERT(reporter, p.isRect(&returnedRect));
     REPORTER_ASSERT(reporter, returnedRect == r);
     test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
     SkVector zeroRadii[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
     rr.setRectRadii(r, zeroRadii);
     p.addRRect(rr);
     bool closed;
     SkPath::Direction dir;
-    REPORTER_ASSERT(reporter, p.isRect(NULL, &closed, &dir));
+    REPORTER_ASSERT(reporter, p.isRect(nullptr, &closed, &dir));
     REPORTER_ASSERT(reporter, closed);
     REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);
     test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
     p.addRRect(rr, SkPath::kCW_Direction);
     p.addRRect(rr, SkPath::kCW_Direction);
     REPORTER_ASSERT(reporter, !p.isConvex());
     p.reset();
     p.addRRect(rr, SkPath::kCCW_Direction);
     p.addRRect(rr, SkPath::kCCW_Direction);
     REPORTER_ASSERT(reporter, !p.isConvex());
@@ skipping 269 matching lines @@
     p.conicTo(1, 2, 3, 4, SK_ScalarInfinity);
     check_path_is_line_pair_and_reset(reporter, &p, 1, 2, 3, 4);
     p.conicTo(1, 2, 3, 4, 1);
     check_path_is_quad_and_reset(reporter, &p, 1, 2, 3, 4);
 }
 
 static void test_get_point(skiatest::Reporter* reporter) {
     SkPath p;
     SkPoint pt = p.getPoint(0);
     REPORTER_ASSERT(reporter, pt == SkPoint::Make(0, 0));
-    REPORTER_ASSERT(reporter, !p.getLastPt(NULL));
+    REPORTER_ASSERT(reporter, !p.getLastPt(nullptr));
     REPORTER_ASSERT(reporter, !p.getLastPt(&pt) && pt == SkPoint::Make(0, 0));
     p.setLastPt(10, 10);
     pt = p.getPoint(0);
     REPORTER_ASSERT(reporter, pt == SkPoint::Make(10, 10));
-    REPORTER_ASSERT(reporter, p.getLastPt(NULL));
+    REPORTER_ASSERT(reporter, p.getLastPt(nullptr));
     p.rMoveTo(10, 10);
     REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt == SkPoint::Make(20, 20));
 }
 
 static void test_contains(skiatest::Reporter* reporter) {
     SkPath p;
     p.setFillType(SkPath::kInverseWinding_FillType);
     REPORTER_ASSERT(reporter, p.contains(0, 0));
     p.setFillType(SkPath::kWinding_FillType);
     REPORTER_ASSERT(reporter, !p.contains(0, 0));
@@ skipping 95 matching lines @@
             REPORTER_ASSERT(reporter, kRepeatCnt == pathRef->countVerbs());
             REPORTER_ASSERT(reporter, 2*kRepeatCnt == pathRef->countPoints());
             REPORTER_ASSERT(reporter, SkPath::kQuad_SegmentMask == pathRef->getSegmentMasks());
             for (int i = 0; i < kRepeatCnt; ++i) {
                 REPORTER_ASSERT(reporter, SkPath::kQuad_Verb == pathRef->atVerb(i));
             }
             ed.resetToSize(0, 0, 0);
         }
 
         {
-            SkScalar* weights = NULL;
+            SkScalar* weights = nullptr;
             ed.growForRepeatedVerb(SkPath::kConic_Verb, kRepeatCnt, &weights);
             REPORTER_ASSERT(reporter, kRepeatCnt == pathRef->countVerbs());
             REPORTER_ASSERT(reporter, 2*kRepeatCnt == pathRef->countPoints());
             REPORTER_ASSERT(reporter, kRepeatCnt == pathRef->countWeights());
             REPORTER_ASSERT(reporter, SkPath::kConic_SegmentMask == pathRef->getSegmentMasks());
             REPORTER_ASSERT(reporter, weights);
             for (int i = 0; i < kRepeatCnt; ++i) {
                 REPORTER_ASSERT(reporter, SkPath::kConic_Verb == pathRef->atVerb(i));
             }
             ed.resetToSize(0, 0, 0);
@@ skipping 35 matching lines @@
 
 static void compare_dump(skiatest::Reporter* reporter, const SkPath& path, bool force,
         bool dumpAsHex, const char* str) {
     SkDynamicMemoryWStream wStream;
     path.dump(&wStream, force, dumpAsHex);
     SkAutoDataUnref data(wStream.copyToData());
     REPORTER_ASSERT(reporter, data->size() == strlen(str));
     if (strlen(str) > 0) {
         REPORTER_ASSERT(reporter, !memcmp(data->data(), str, strlen(str)));
     } else {
-        REPORTER_ASSERT(reporter, data->data() == NULL || !memcmp(data->data(), str, strlen(str)));
+        REPORTER_ASSERT(reporter, data->data() == nullptr || !memcmp(data->data(), str, strlen(str)));
     }
 }
 
 static void test_dump(skiatest::Reporter* reporter) {
     SkPath p;
     compare_dump(reporter, p, false, false, "");
     compare_dump(reporter, p, true, false, "");
     p.moveTo(1, 2);
     p.lineTo(3, 4);
     compare_dump(reporter, p, false, false, "path.moveTo(1, 2);\n"
@@ skipping 150 matching lines @@
     p.addRect(bounds);
     check_convex_bounds(reporter, p, bounds);
     // we have only lines
     REPORTER_ASSERT(reporter, SkPath::kLine_SegmentMask == p.getSegmentMasks());
     REPORTER_ASSERT(reporter, !p.isEmpty());
 
     REPORTER_ASSERT(reporter, p != empty);
     REPORTER_ASSERT(reporter, !(p == empty));
 
     // do getPoints and getVerbs return the right result
-    REPORTER_ASSERT(reporter, p.getPoints(NULL, 0) == 4);
-    REPORTER_ASSERT(reporter, p.getVerbs(NULL, 0) == 5);
+    REPORTER_ASSERT(reporter, p.getPoints(nullptr, 0) == 4);
+    REPORTER_ASSERT(reporter, p.getVerbs(nullptr, 0) == 5);
     SkPoint pts[4];
     int count = p.getPoints(pts, 4);
     REPORTER_ASSERT(reporter, count == 4);
     uint8_t verbs[6];
     verbs[5] = 0xff;
     p.getVerbs(verbs, 5);
     REPORTER_ASSERT(reporter, SkPath::kMove_Verb == verbs[0]);
     REPORTER_ASSERT(reporter, SkPath::kLine_Verb == verbs[1]);
     REPORTER_ASSERT(reporter, SkPath::kLine_Verb == verbs[2]);
     REPORTER_ASSERT(reporter, SkPath::kLine_Verb == verbs[3]);
     REPORTER_ASSERT(reporter, SkPath::kClose_Verb == verbs[4]);
     REPORTER_ASSERT(reporter, 0xff == verbs[5]);
     bounds2.set(pts, 4);
     REPORTER_ASSERT(reporter, bounds == bounds2);
 
     bounds.offset(SK_Scalar1*3, SK_Scalar1*4);
     p.offset(SK_Scalar1*3, SK_Scalar1*4);
     REPORTER_ASSERT(reporter, bounds == p.getBounds());
 
-    REPORTER_ASSERT(reporter, p.isRect(NULL));
+    REPORTER_ASSERT(reporter, p.isRect(nullptr));
     bounds2.setEmpty();
     REPORTER_ASSERT(reporter, p.isRect(&bounds2));
     REPORTER_ASSERT(reporter, bounds == bounds2);
 
     // now force p to not be a rect
     bounds.set(0, 0, SK_Scalar1/2, SK_Scalar1/2);
     p.addRect(bounds);
-    REPORTER_ASSERT(reporter, !p.isRect(NULL));
+    REPORTER_ASSERT(reporter, !p.isRect(nullptr));
 
     // Test an edge case w.r.t. the bound returned by isRect (i.e., the
     // path has a trailing moveTo. Please see crbug.com\445368)
     {
         SkRect r;
         p.reset();
         p.addRect(bounds);
         REPORTER_ASSERT(reporter, p.isRect(&r));
         REPORTER_ASSERT(reporter, r == bounds);
         // add a moveTo outside of our bounds
@@ skipping 55 matching lines @@
     PathTest_Private::TestPathTo(reporter);
     PathRefTest_Private::TestPathRef(reporter);
     PathTest_Private::TestPathrefListeners(reporter);
     test_dump(reporter);
     test_path_crbug389050(reporter);
     test_path_crbugskia2820(reporter);
     test_skbug_3469(reporter);
     test_skbug_3239(reporter);
     test_bounds_crbug_513799(reporter);
 }