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

webrtc/base/taskrunner.cc

 /*
  *  Copyright 2004 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 59 matching lines @@
       }
     }
   }
   // Tasks are deleted when running has paused
   bool need_timeout_recalc = false;
   for (size_t i = 0; i < tasks_.size(); ++i) {
     if (tasks_[i]->IsDone()) {
       Task* task = tasks_[i];
       if (next_timeout_task_ &&
           task->unique_id() == next_timeout_task_->unique_id()) {
-        next_timeout_task_ = NULL;
+        next_timeout_task_ = nullptr;
         need_timeout_recalc = true;
       }
 
 #if RTC_DCHECK_IS_ON
       deleting_task_ = task;
 #endif
       delete task;
 #if RTC_DCHECK_IS_ON
-      deleting_task_ = NULL;
+      deleting_task_ = nullptr;
 #endif
-      tasks_[i] = NULL;
+      tasks_[i] = nullptr;
     }
   }
-  // Finally, remove nulls
+  // Finally, remove nulls.
   std::vector<Task *>::iterator it;
-  it = std::remove(tasks_.begin(),
-                   tasks_.end(),
-                   reinterpret_cast<Task *>(NULL));
+  it = std::remove(tasks_.begin(), tasks_.end(), nullptr);
 
   tasks_.erase(it, tasks_.end());
 
   if (need_timeout_recalc)
-    RecalcNextTimeout(NULL);
+    RecalcNextTimeout(nullptr);
 
   // Make sure that adjustments are done to account
   // for any timeout changes (but don't call this
   // while being destroyed since it calls a pure virtual function).
   if (!in_destructor)
     CheckForTimeoutChange(previous_timeout_time);
 
   tasks_running_ = false;
 }
 
 void TaskRunner::PollTasks() {
   // see if our "next potentially timed-out task" has indeed timed out.
   // If it has, wake it up, then queue up the next task in line
   // Repeat while we have new timed-out tasks.
   // TODO: We need to guard against WakeTasks not updating
   // next_timeout_task_. Maybe also add documentation in the header file once
   // we understand this code better.
-  Task* old_timeout_task = NULL;
+  Task* old_timeout_task = nullptr;
   while (next_timeout_task_ &&
       old_timeout_task != next_timeout_task_ &&
       next_timeout_task_->TimedOut()) {
     old_timeout_task = next_timeout_task_;
     next_timeout_task_->Wake();
     WakeTasks();
   }
 }
 
 int64_t TaskRunner::next_task_timeout() const {
   if (next_timeout_task_) {
     return next_timeout_task_->timeout_time();
   }
   return 0;
 }
 
 // this function gets called frequently -- when each task changes
 // state to something other than DONE, ERROR or BLOCKED, it calls
 // ResetTimeout(), which will call this function to make sure that
 // the next timeout-able task hasn't changed.  The logic in this function
 // prevents RecalcNextTimeout() from getting called in most cases,
 // effectively making the task scheduler O-1 instead of O-N
 
 void TaskRunner::UpdateTaskTimeout(Task* task,
                                    int64_t previous_task_timeout_time) {
-  RTC_DCHECK(task != NULL);
+  RTC_DCHECK(task != nullptr);
   int64_t previous_timeout_time = next_task_timeout();
-  bool task_is_timeout_task = next_timeout_task_ != NULL &&
+  bool task_is_timeout_task =
+      next_timeout_task_ != nullptr &&
       task->unique_id() == next_timeout_task_->unique_id();
   if (task_is_timeout_task) {
     previous_timeout_time = previous_task_timeout_time;
   }
 
   // if the relevant task has a timeout, then
   // check to see if it's closer than the current
   // "about to timeout" task
   if (task->timeout_time()) {
-    if (next_timeout_task_ == NULL ||
+    if (next_timeout_task_ == nullptr ||
         (task->timeout_time() <= next_timeout_task_->timeout_time())) {
       next_timeout_task_ = task;
     }
   } else if (task_is_timeout_task) {
     // otherwise, if the task doesn't have a timeout,
     // and it used to be our "about to timeout" task,
     // walk through all the tasks looking for the real
     // "about to timeout" task
     RecalcNextTimeout(task);
   }
 
   // Note when task_running_, then the running routine
   // (TaskRunner::InternalRunTasks) is responsible for calling
   // CheckForTimeoutChange.
   if (!tasks_running_) {
     CheckForTimeoutChange(previous_timeout_time);
   }
 }
 
 void TaskRunner::RecalcNextTimeout(Task *exclude_task) {
   // walk through all the tasks looking for the one
   // which satisfies the following:
   //   it's not finished already
   //   we're not excluding it
   //   it has the closest timeout time
 
   int64_t next_timeout_time = 0;
-  next_timeout_task_ = NULL;
+  next_timeout_task_ = nullptr;
 
   for (size_t i = 0; i < tasks_.size(); ++i) {
     Task *task = tasks_[i];
     // if the task isn't complete, and it actually has a timeout time
     if (!task->IsDone() && (task->timeout_time() > 0))
       // if it doesn't match our "exclude" task
-      if (exclude_task == NULL ||
+      if (exclude_task == nullptr ||
           exclude_task->unique_id() != task->unique_id())
         // if its timeout time is sooner than our current timeout time
         if (next_timeout_time == 0 ||
             task->timeout_time() <= next_timeout_time) {
           // set this task as our next-to-timeout
           next_timeout_time = task->timeout_time();
           next_timeout_task_ = task;
         }
   }
 }
 
 void TaskRunner::CheckForTimeoutChange(int64_t previous_timeout_time) {
   int64_t next_timeout = next_task_timeout();
   bool timeout_change = (previous_timeout_time == 0 && next_timeout != 0) ||
       next_timeout < previous_timeout_time ||
       (previous_timeout_time <= CurrentTime() &&
        previous_timeout_time != next_timeout);
   if (timeout_change) {
     OnTimeoutChange();
   }
 }
 
 } // namespace rtc