Style Change: NULL->nullptr

tools/flags/SkCommandLineFlags.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 "SkCommandLineFlags.h"
 #include "SkTDArray.h"
 #include "SkTSort.h"
@@ skipping 11 matching lines @@
     info->fDefaultString.set(defaultValue);
 
     info->fStrings = pStrings;
     SetDefaultStrings(pStrings, defaultValue);
     return true;
 }
 
 void SkFlagInfo::SetDefaultStrings(SkCommandLineFlags::StringArray* pStrings,
                                    const char* defaultValue) {
     pStrings->reset();
-    if (NULL == defaultValue) {
+    if (nullptr == defaultValue) {
         return;
     }
     // If default is "", leave the array empty.
     size_t defaultLength = strlen(defaultValue);
     if (defaultLength > 0) {
         const char* const defaultEnd = defaultValue + defaultLength;
         const char* begin = defaultValue;
         while (true) {
             while (begin < defaultEnd && ' ' == *begin) {
                 begin++;
@@ skipping 218 matching lines @@
                 SkDebugf("Requested help for unrecognized flags:\n");
                 for (int k = 0; k < helpFlags.count(); k++) {
                     SkDebugf("    --%s\n", helpFlags[k]);
                 }
             }
             helpPrinted = true;
         }
         if (!helpPrinted) {
             bool flagMatched = false;
             SkFlagInfo* flag = gHead;
-            while (flag != NULL) {
+            while (flag != nullptr) {
                 if (flag->match(argv[i])) {
                     flagMatched = true;
                     switch (flag->getFlagType()) {
                         case SkFlagInfo::kBool_FlagType:
                             // Can be handled by match, above, but can also be set by the next
                             // string.
                             if (i+1 < argc && !SkStrStartsWith(argv[i+1], '-')) {
                                 i++;
                                 bool value;
                                 if (parse_bool_arg(argv[i], &value)) {
                                     flag->setBool(value);
                                 }
                             }
                             break;
                         case SkFlagInfo::kString_FlagType:
                             flag->resetStrings();
                             // Add all arguments until another flag is reached.
                             while (i+1 < argc) {
-                                char* end = NULL;
+                                char* end = nullptr;
                                 // Negative numbers aren't flags.
                                 ignore_result(strtod(argv[i+1], &end));
                                 if (end == argv[i+1] && SkStrStartsWith(argv[i+1], '-')) {
                                     break;
                                 }
                                 i++;
                                 flag->append(argv[i]);
                             }
                             break;
                         case SkFlagInfo::kInt_FlagType:
@@ skipping 23 matching lines @@
                 } else {
                     SkDebugf("Got unknown flag '%s'. Exiting.\n", argv[i]);
                     exit(-1);
                 }
             }
         }
     }
     // Since all of the flags have been set, release the memory used by each
     // flag. FLAGS_x can still be used after this.
     SkFlagInfo* flag = gHead;
-    gHead = NULL;
-    while (flag != NULL) {
+    gHead = nullptr;
+    while (flag != nullptr) {
         SkFlagInfo* next = flag->next();
         delete flag;
         flag = next;
     }
     if (helpPrinted) {
         exit(0);
     }
 }
 
 namespace {
@@ skipping 31 matching lines @@
 }
 
 }  // namespace
 
 bool SkCommandLineFlags::ShouldSkip(const SkTDArray<const char*>& strings, const char* name) {
     return ShouldSkipImpl(strings, name);
 }
 bool SkCommandLineFlags::ShouldSkip(const StringArray& strings, const char* name) {
     return ShouldSkipImpl(strings, name);
 }