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

webrtc/base/messagequeue.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.
  */
 #include <algorithm>
@@ skipping 31 matching lines @@
   const CriticalSection* const cs_;
   bool* locked_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(DebugNonReentrantCritScope);
 };
 }  // namespace
 
 //------------------------------------------------------------------
 // MessageQueueManager
 
-MessageQueueManager* MessageQueueManager::instance_ = NULL;
+MessageQueueManager* MessageQueueManager::instance_ = nullptr;
 
 MessageQueueManager* MessageQueueManager::Instance() {
   // Note: This is not thread safe, but it is first called before threads are
   // spawned.
   if (!instance_)
     instance_ = new MessageQueueManager;
   return instance_;
 }
 
 bool MessageQueueManager::IsInitialized() {
-  return instance_ != NULL;
+  return instance_ != nullptr;
 }
 
 MessageQueueManager::MessageQueueManager() : locked_(false) {}
 
 MessageQueueManager::~MessageQueueManager() {
 }
 
 void MessageQueueManager::Add(MessageQueue *message_queue) {
   return Instance()->AddInternal(message_queue);
 }
@@ skipping 18 matching lines @@
     DebugNonReentrantCritScope cs(&crit_, &locked_);
     std::vector<MessageQueue *>::iterator iter;
     iter = std::find(message_queues_.begin(), message_queues_.end(),
                      message_queue);
     if (iter != message_queues_.end()) {
       message_queues_.erase(iter);
     }
     destroy = message_queues_.empty();
   }
   if (destroy) {
-    instance_ = NULL;
+    instance_ = nullptr;
     delete this;
   }
 }
 
 void MessageQueueManager::Clear(MessageHandler *handler) {
   // If there isn't a message queue manager instance, then there aren't any
   // queues to remove this handler from.
   if (!instance_) return;
   return Instance()->ClearInternal(handler);
 }
@@ skipping 94 matching lines @@
   if (fDestroyed_) {
     return;
   }
 
   fDestroyed_ = true;
   // The signal is done from here to ensure
   // that it always gets called when the queue
   // is going away.
   SignalQueueDestroyed();
   MessageQueueManager::Remove(this);
-  Clear(NULL);
+  Clear(nullptr);
 
   SharedScope ss(&ss_lock_);
   if (ss_) {
-    ss_->SetMessageQueue(NULL);
+    ss_->SetMessageQueue(nullptr);
   }
 }
 
 SocketServer* MessageQueue::socketserver() {
   SharedScope ss(&ss_lock_);
   return ss_;
 }
 
 void MessageQueue::set_socketserver(SocketServer* ss) {
   // Need to lock exclusively here to prevent simultaneous modifications from
@@ skipping 94 matching lines @@
       // Log a warning for time-sensitive messages that we're late to deliver.
       if (pmsg->ts_sensitive) {
         int64_t delay = TimeDiff(msCurrent, pmsg->ts_sensitive);
         if (delay > 0) {
           LOG_F(LS_WARNING) << "id: " << pmsg->message_id << "  delay: "
                             << (delay + kMaxMsgLatency) << "ms";
         }
       }
       // If this was a dispose message, delete it and skip it.
       if (MQID_DISPOSE == pmsg->message_id) {
-        RTC_DCHECK(NULL == pmsg->phandler);
+        RTC_DCHECK(nullptr == pmsg->phandler);
         delete pmsg->pdata;
         *pmsg = Message();
         continue;
       }
       return true;
     }
 
     if (IsQuitting())
       break;
 
@@ skipping 191 matching lines @@
   pmsg->phandler->OnMessage(pmsg);
   int64_t end_time = TimeMillis();
   int64_t diff = TimeDiff(end_time, start_time);
   if (diff >= kSlowDispatchLoggingThreshold) {
     LOG(LS_INFO) << "Message took " << diff << "ms to dispatch. Posted from: "
                  << pmsg->posted_from.ToString();
   }
 }
 
 }  // namespace rtc