Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/flags.cc

 /*
  *  Copyright 2006 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 88 matching lines @@
     printf("  current value: ");
     PrintFlagValue(type_, variable_);
   }
   printf("\n");
 }
 
 
 // -----------------------------------------------------------------------------
 // Implementation of FlagList
 
-Flag* FlagList::list_ = NULL;
-
+Flag* FlagList::list_ = nullptr;
 
 FlagList::FlagList() {
-  list_ = NULL;
+  list_ = nullptr;
 }
 
 void FlagList::Print(const char* file, bool print_current_value) {
   // Since flag registration is likely by file (= C++ file),
   // we don't need to sort by file and still get grouped output.
-  const char* current = NULL;
-  for (Flag* f = list_; f != NULL; f = f->next()) {
-    if (file == NULL || file == f->file()) {
+  const char* current = nullptr;
+  for (Flag* f = list_; f != nullptr; f = f->next()) {
+    if (file == nullptr || file == f->file()) {
       if (current != f->file()) {
         printf("Flags from %s:\n", f->file());
         current = f->file();
       }
       f->Print(print_current_value);
     }
   }
 }
 
 
 Flag* FlagList::Lookup(const char* name) {
   Flag* f = list_;
-  while (f != NULL && strcmp(name, f->name()) != 0)
+  while (f != nullptr && strcmp(name, f->name()) != 0)
     f = f->next();
   return f;
 }
 
 
 void FlagList::SplitArgument(const char* arg,
                              char* buffer, int buffer_size,
                              const char** name, const char** value,
                              bool* is_bool) {
-  *name = NULL;
-  *value = NULL;
+  *name = nullptr;
+  *value = nullptr;
   *is_bool = false;
 
   if (*arg == '-') {
     // find the begin of the flag name
     arg++;  // remove 1st '-'
     if (*arg == '-')
       arg++;  // remove 2nd '-'
     if (arg[0] == 'n' && arg[1] == 'o') {
       arg += 2;  // remove "no"
       *is_bool = true;
@@ skipping 26 matching lines @@
     int j = i;  // j > 0
     const char* arg = argv[i++];
 
     // split arg into flag components
     char buffer[1024];
     const char* name;
     const char* value;
     bool is_bool;
     SplitArgument(arg, buffer, sizeof buffer, &name, &value, &is_bool);
 
-    if (name != NULL) {
+    if (name != nullptr) {
       // lookup the flag
       Flag* flag = Lookup(name);
-      if (flag == NULL) {
+      if (flag == nullptr) {
         fprintf(stderr, "Error: unrecognized flag %s\n", arg);
         return j;
       }
 
       // if we still need a flag value, use the next argument if available
-      if (flag->type() != Flag::BOOL && value == NULL) {
+      if (flag->type() != Flag::BOOL && value == nullptr) {
         if (i < *argc) {
           value = argv[i++];
         } else {
           fprintf(stderr, "Error: missing value for flag %s of type %s\n",
             arg, Type2String(flag->type()));
           return j;
         }
       }
 
       // set the flag
       char empty[] = { '\0' };
       char* endp = empty;
       switch (flag->type()) {
         case Flag::BOOL:
           *flag->bool_variable() = !is_bool;
           break;
         case Flag::INT:
           *flag->int_variable() = strtol(value, &endp, 10);
           break;
         case Flag::FLOAT:
           *flag->float_variable() = strtod(value, &endp);
           break;
         case Flag::STRING:
           *flag->string_variable() = value;
           break;
       }
 
       // handle errors
-      if ((flag->type() == Flag::BOOL && value != NULL) ||
-          (flag->type() != Flag::BOOL && is_bool) ||
-          *endp != '\0') {
+      if ((flag->type() == Flag::BOOL && value != nullptr) ||
+          (flag->type() != Flag::BOOL && is_bool) || *endp != '\0') {
         fprintf(stderr, "Error: illegal value for flag %s of type %s\n",
           arg, Type2String(flag->type()));
         return j;
       }
 
       // remove the flag & value from the command
       if (remove_flags)
         while (j < i)
-          argv[j++] = NULL;
+          argv[j++] = nullptr;
     }
   }
 
   // shrink the argument list
   if (remove_flags) {
     int j = 1;
     for (int i = 1; i < *argc; i++) {
-      if (argv[i] != NULL)
+      if (argv[i] != nullptr)
         argv[j++] = argv[i];
     }
     *argc = j;
   }
 
   // parsed all flags successfully
   return 0;
 }
 
 void FlagList::Register(Flag* flag) {
@@ skipping 32 matching lines @@
   // need to free each string in the array, and then the array.
   for(int i = 0; i < argc_; i++) {
     delete[] argv_[i];
   }
 
   delete[] argv_;
 }
 #endif  // WEBRTC_WIN
 
 }  // namespace rtc