Style Change: NULL->nullptr

tests/PathOpsSkpClipTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 // #include "OverwriteLine.h"
 #include "Resources.h"
@@ skipping 425 matching lines @@
 static void writePict(const SkBitmap& bitmap, const char* outDir, const char* pngName) {
     SkString outFile = get_sum_path(outDir);
     outFile.appendf("%s%s", PATH_SLASH, pngName);
     if (!SkImageEncoder::EncodeFile(outFile.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("unable to encode gr %s (width=%d height=%d)\n", pngName,
                     bitmap.width(), bitmap.height());
     }
 }
 
 void TestResult::testOne() {
-    SkPicture* pic = NULL;
+    SkPicture* pic = nullptr;
     {
     #if DEBUG_SHOW_TEST_NAME
         if (fTestStep == kCompareBits) {
             SkString testName(fFilename);
             const char http[] = "http";
             if (testName.startsWith(http)) {
                 testName.remove(0, sizeof(http) - 1);
             }
             while (testName.startsWith("_")) {
                 testName.remove(0, 1);
@@ skipping 69 matching lines @@
 
 DEFINE_string2(match, m, "PathOpsSkpClipThreaded",
         "[~][^]substring[$] [...] of test name to run.\n"
         "Multiple matches may be separated by spaces.\n"
         "~ causes a matching test to always be skipped\n"
         "^ requires the start of the test to match\n"
         "$ requires the end of the test to match\n"
         "^ and $ requires an exact match\n"
         "If a test does not match any list entry,\n"
         "it is skipped unless some list entry starts with ~");
-DEFINE_string2(dir, d, NULL, "range of directories (e.g., 1-100)");
-DEFINE_string2(skp, s, NULL, "skp to test");
+DEFINE_string2(dir, d, nullptr, "range of directories (e.g., 1-100)");
+DEFINE_string2(skp, s, nullptr, "skp to test");
 DEFINE_bool2(single, z, false, "run tests on a single thread internally.");
 DEFINE_int32(testIndex, 0, "override local test index (PathOpsSkpClipOneOff only).");
 DEFINE_bool2(verbose, v, false, "enable verbose output.");
 
 static bool verbose() {
     return FLAGS_verbose;
 }
 
 class Dirs {
 public:
@@ skipping 59 matching lines @@
 class Filenames {
 public:
     Filenames()
         : fIndex(-1) {
     }
 
     const char* next() {
         while (fNames && ++fIndex < fNames->count()) {
             return (*fNames)[fIndex];
         }
-        return NULL;
+        return nullptr;
     }
 
     void set(const SkCommandLineFlags::StringArray& names) {
         fNames = &names;
     }
 
 private:
     int fIndex;
     const SkCommandLineFlags::StringArray* fNames;
 } gNames;
@@ skipping 70 matching lines @@
     }
 }
 
 bool Less(const SortByName& a, const SortByName& b);
 bool Less(const SortByName& a, const SortByName& b) {
     return a < b;
 }
 
 static bool doOneDir(TestState* state, bool threaded) {
     int dirNo = state->fResult.fDirNo;
-    SkString dirName = get_in_path(dirNo, NULL);
+    SkString dirName = get_in_path(dirNo, nullptr);
     if (!dirName.size()) {
         return false;
     }
     SkTDArray<TestResult> tests[1];
     SkTDArray<SortByName*> sorted[1];
     if (!buildTestDir(dirNo, dirNo, tests, sorted)) {
         return false;
     }
     SkOSFile::Iter iter(dirName.c_str(), "skp");
     SkString filename;
@@ skipping 186 matching lines @@
     int dirCount = lastDirNo - firstDirNo + 1;
     SkAutoTDeleteArray<SkTDArray<TestResult> > tests(new SkTDArray<TestResult>[dirCount]);
     SkAutoTDeleteArray<SkTDArray<SortByName*> > sorted(new SkTDArray<SortByName*>[dirCount]);
     if (!buildTests(tests.get(), sorted.get())) {
         return;
     }
     TestRunner testRunner;
     int dirNo;
     gDirs.reset();
     while ((dirNo = gDirs.next()) > 0) {
-        SkString dirName = get_in_path(dirNo, NULL);
+        SkString dirName = get_in_path(dirNo, nullptr);
         if (!dirName.size()) {
             continue;
         }
         SkOSFile::Iter iter(dirName.c_str(), "skp");
         SkString filename;
         while (iter.next(&filename)) {
             for (size_t index = 0; index < skipOverCount; ++index) {
                 if (skipOver[index].directory == dirNo
                         && strcmp(filename.c_str(), skipOver[index].filename) == 0) {
                     goto checkEarlyExit;
@@ skipping 10 matching lines @@
                             &testSkpClip, dirNo, filename.c_str(), &testRunner);
                 }
             }
     checkEarlyExit:
             ;
         }
 
     }
     testRunner.render();
     SkAutoTDeleteArray<SkTDArray<TestResult> > results(new SkTDArray<TestResult>[dirCount]);
-    if (!buildTests(results.get(), NULL)) {
+    if (!buildTests(results.get(), nullptr)) {
         return;
     }
     SkTDArray<TestResult> allResults;
     for (int dirNo = firstDirNo; dirNo <= lastDirNo; ++dirNo) {
         SkTDArray<TestResult>& array = results.get()[dirNo - firstDirNo];
         allResults.append(array.count(), array.begin());
     }
     int allCount = allResults.count();
     SkTDArray<SortByPixel*> pixels;
     SkTDArray<SortByTime*> times;
@@ skipping 78 matching lines @@
 
 class Iter {
 public:
     Iter() { this->reset(); }
     void reset() { fReg = TestRegistry::Head(); }
 
     Test* next() {
         if (fReg) {
             TestRegistry::Factory fact = fReg->factory();
             fReg = fReg->next();
-            Test* test = fact(NULL);
+            Test* test = fact(nullptr);
             return test;
         }
-        return NULL;
+        return nullptr;
     }
 
 private:
     const TestRegistry* fReg;
 };
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
     SetupCrashHandler();
     SkCommandLineFlags::SetUsage("");
@@ skipping 30 matching lines @@
     header.append(" SK_DEBUG");
 #else
     header.append(" SK_RELEASE");
 #endif
     if (FLAGS_verbose) {
         header.appendf("\n");
     }
     SkDebugf("%s", header.c_str());
     Iter iter;
     Test* test;
-    while ((test = iter.next()) != NULL) {
+    while ((test = iter.next()) != nullptr) {
         SkAutoTDelete<Test> owned(test);
         if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, test->getName())) {
             test->run();
         }
     }
     SkGraphics::Term();
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif