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

webrtc/base/thread.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 25 matching lines @@
   return &thread_manager;
 }
 
 // static
 Thread* Thread::Current() {
   return ThreadManager::Instance()->CurrentThread();
 }
 
 #if defined(WEBRTC_POSIX)
 ThreadManager::ThreadManager() {
-  pthread_key_create(&key_, NULL);
+  pthread_key_create(&key_, nullptr);
 #ifndef NO_MAIN_THREAD_WRAPPING
   WrapCurrentThread();
 #endif
 #if defined(WEBRTC_MAC)
   // This is necessary to alert the cocoa runtime of the fact that
   // we are running in a multithreaded environment.
   InitCocoaMultiThreading();
 #endif
 }
 
@@ skipping 34 matching lines @@
   return static_cast<Thread *>(TlsGetValue(key_));
 }
 
 void ThreadManager::SetCurrentThread(Thread *thread) {
   TlsSetValue(key_, thread);
 }
 #endif
 
 Thread *ThreadManager::WrapCurrentThread() {
   Thread* result = CurrentThread();
-  if (NULL == result) {
+  if (nullptr == result) {
     result = new Thread();
     result->WrapCurrentWithThreadManager(this, true);
   }
   return result;
 }
 
 void ThreadManager::UnwrapCurrentThread() {
   Thread* t = CurrentThread();
   if (t && !(t->IsOwned())) {
     t->UnwrapCurrent();
@@ skipping 15 matching lines @@
   RTC_DCHECK(thread_->IsCurrent());
   thread_->SetAllowBlockingCalls(previous_state_);
 }
 
 Thread::Thread() : Thread(SocketServer::CreateDefault()) {}
 
 Thread::Thread(SocketServer* ss)
     : MessageQueue(ss, false),
       running_(true, false),
 #if defined(WEBRTC_WIN)
-      thread_(NULL),
+      thread_(nullptr),
       thread_id_(0),
 #endif
       owned_(true),
       blocking_calls_allowed_(true) {
   SetName("Thread", this);  // default name
   DoInit();
 }
 
 Thread::Thread(std::unique_ptr<SocketServer> ss)
     : MessageQueue(std::move(ss), false),
       running_(true, false),
 #if defined(WEBRTC_WIN)
-      thread_(NULL),
+      thread_(nullptr),
       thread_id_(0),
 #endif
       owned_(true),
       blocking_calls_allowed_(true) {
   SetName("Thread", this);  // default name
   DoInit();
 }
 
 Thread::~Thread() {
   Stop();
@@ skipping 14 matching lines @@
 
 #if defined(WEBRTC_WIN)
   ::Sleep(milliseconds);
   return true;
 #else
   // POSIX has both a usleep() and a nanosleep(), but the former is deprecated,
   // so we use nanosleep() even though it has greater precision than necessary.
   struct timespec ts;
   ts.tv_sec = milliseconds / 1000;
   ts.tv_nsec = (milliseconds % 1000) * 1000000;
-  int ret = nanosleep(&ts, NULL);
+  int ret = nanosleep(&ts, nullptr);
   if (ret != 0) {
     LOG_ERR(LS_WARNING) << "nanosleep() returning early";
     return false;
   }
   return true;
 #endif
 }
 
 bool Thread::SetName(const std::string& name, const void* obj) {
   if (running()) return false;
@@ skipping 15 matching lines @@
   Restart();  // reset IsQuitting() if the thread is being restarted
 
   // Make sure that ThreadManager is created on the main thread before
   // we start a new thread.
   ThreadManager::Instance();
 
   ThreadInit* init = new ThreadInit;
   init->thread = this;
   init->runnable = runnable;
 #if defined(WEBRTC_WIN)
-  thread_ = CreateThread(NULL, 0, PreRun, init, 0, &thread_id_);
+  thread_ = CreateThread(nullptr, 0, PreRun, init, 0, &thread_id_);
   if (thread_) {
     running_.Set();
   } else {
     return false;
   }
 #elif defined(WEBRTC_POSIX)
   pthread_attr_t attr;
   pthread_attr_init(&attr);
 
   int error_code = pthread_create(&thread_, &attr, PreRun, init);
   if (0 != error_code) {
     LOG(LS_ERROR) << "Unable to create pthread, error " << error_code;
     return false;
   }
   running_.Set();
 #endif
   return true;
 }
 
 bool Thread::WrapCurrent() {
   return WrapCurrentWithThreadManager(ThreadManager::Instance(), true);
 }
 
 void Thread::UnwrapCurrent() {
   // Clears the platform-specific thread-specific storage.
-  ThreadManager::Instance()->SetCurrentThread(NULL);
+  ThreadManager::Instance()->SetCurrentThread(nullptr);
 #if defined(WEBRTC_WIN)
-  if (thread_ != NULL) {
+  if (thread_ != nullptr) {
     if (!CloseHandle(thread_)) {
       LOG_GLE(LS_ERROR) << "When unwrapping thread, failed to close handle.";
     }
-    thread_ = NULL;
+    thread_ = nullptr;
   }
 #endif
   running_.Reset();
 }
 
 void Thread::SafeWrapCurrent() {
   WrapCurrentWithThreadManager(ThreadManager::Instance(), false);
 }
 
 void Thread::Join() {
   if (running()) {
     RTC_DCHECK(!IsCurrent());
     if (Current() && !Current()->blocking_calls_allowed_) {
       LOG(LS_WARNING) << "Waiting for the thread to join, "
                       << "but blocking calls have been disallowed";
     }
 
 #if defined(WEBRTC_WIN)
-    RTC_DCHECK(thread_ != NULL);
+    RTC_DCHECK(thread_ != nullptr);
     WaitForSingleObject(thread_, INFINITE);
     CloseHandle(thread_);
-    thread_ = NULL;
+    thread_ = nullptr;
     thread_id_ = 0;
 #elif defined(WEBRTC_POSIX)
     void *pv;
     pthread_join(thread_, &pv);
 #endif
     running_.Reset();
   }
 }
 
 bool Thread::SetAllowBlockingCalls(bool allow) {
@@ skipping 67 matching lines @@
   msg.pdata = pdata;
   if (IsCurrent()) {
     phandler->OnMessage(&msg);
     return;
   }
 
   AssertBlockingIsAllowedOnCurrentThread();
 
   AutoThread thread;
   Thread *current_thread = Thread::Current();
-  RTC_DCHECK(current_thread != NULL);  // AutoThread ensures this
+  RTC_DCHECK(current_thread != nullptr);  // AutoThread ensures this
 
   bool ready = false;
   {
     CritScope cs(&crit_);
     _SendMessage smsg;
     smsg.thread = current_thread;
     smsg.msg = msg;
     smsg.ready = &ready;
     sendlist_.push_back(smsg);
   }
@@ skipping 24 matching lines @@
   // Post while waiting for the Send to complete, which means that when we exit
   // this loop, we need to issue another WakeUp, or else the Posted message
   // won't be processed in a timely manner.
 
   if (waited) {
     current_thread->socketserver()->WakeUp();
   }
 }
 
 void Thread::ReceiveSends() {
-  ReceiveSendsFromThread(NULL);
+  ReceiveSendsFromThread(nullptr);
 }
 
 void Thread::ReceiveSendsFromThread(const Thread* source) {
   // Receive a sent message. Cleanup scenarios:
   // - thread sending exits: We don't allow this, since thread can exit
   //   only via Join, so Send must complete.
   // - thread receiving exits: Wakeup/set ready in Thread::Clear()
   // - object target cleared: Wakeup/set ready in Thread::Clear()
   _SendMessage smsg;
 
   crit_.Enter();
   while (PopSendMessageFromThread(source, &smsg)) {
     crit_.Leave();
 
     smsg.msg.phandler->OnMessage(&smsg.msg);
 
     crit_.Enter();
     *smsg.ready = true;
     smsg.thread->socketserver()->WakeUp();
   }
   crit_.Leave();
 }
 
 bool Thread::PopSendMessageFromThread(const Thread* source, _SendMessage* msg) {
   for (std::list<_SendMessage>::iterator it = sendlist_.begin();
        it != sendlist_.end(); ++it) {
-    if (it->thread == source || source == NULL) {
+    if (it->thread == source || source == nullptr) {
       *msg = *it;
       sendlist_.erase(it);
       return true;
     }
   }
   return false;
 }
 
 void Thread::InvokeInternal(const Location& posted_from,
                             MessageHandler* handler) {
   TRACE_EVENT2("webrtc", "Thread::Invoke", "src_file_and_line",
                posted_from.file_and_line(), "src_func",
                posted_from.function_name());
   Send(posted_from, handler);
 }
 
 void Thread::Clear(MessageHandler* phandler,
                    uint32_t id,
                    MessageList* removed) {
   CritScope cs(&crit_);
 
   // Remove messages on sendlist_ with phandler
   // Object target cleared: remove from send list, wakeup/set ready
-  // if sender not NULL.
+  // if sender not null.
 
   std::list<_SendMessage>::iterator iter = sendlist_.begin();
   while (iter != sendlist_.end()) {
     _SendMessage smsg = *iter;
     if (smsg.msg.Match(phandler, id)) {
       if (removed) {
         removed->push_back(smsg.msg);
       } else {
         delete smsg.msg.pdata;
       }
@@ skipping 61 matching lines @@
 
 AutoThread::AutoThread() {
   if (!ThreadManager::Instance()->CurrentThread()) {
     ThreadManager::Instance()->SetCurrentThread(this);
   }
 }
 
 AutoThread::~AutoThread() {
   Stop();
   if (ThreadManager::Instance()->CurrentThread() == this) {
-    ThreadManager::Instance()->SetCurrentThread(NULL);
+    ThreadManager::Instance()->SetCurrentThread(nullptr);
   }
 }
 
 #if defined(WEBRTC_WIN)
 ComThread::~ComThread() {
   Stop();
 }
 
 void ComThread::Run() {
-  HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+  HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
   RTC_DCHECK(SUCCEEDED(hr));
   if (SUCCEEDED(hr)) {
     Thread::Run();
     CoUninitialize();
   } else {
     LOG(LS_ERROR) << "CoInitialize failed, hr=" << hr;
   }
 }
 #endif
 
 }  // namespace rtc