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

webrtc/base/thread.h

 /*
  *  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 38 matching lines @@
   // If there already *is* a Thread object corresponding to this thread,
   // this method will return that.  Otherwise it creates a new Thread
   // object whose wrapped() method will return true, and whose
   // handle will, on Win32, be opened with only synchronization privileges -
   // if you need more privilegs, rather than changing this method, please
   // write additional code to adjust the privileges, or call a different
   // factory method of your own devising, because this one gets used in
   // unexpected contexts (like inside browser plugins) and it would be a
   // shame to break it.  It is also conceivable on Win32 that we won't even
   // be able to get synchronization privileges, in which case the result
-  // will have a NULL handle.
+  // will have a null handle.
   Thread *WrapCurrentThread();
   void UnwrapCurrentThread();
 
  private:
 #if defined(WEBRTC_POSIX)
   pthread_key_t key_;
 #endif
 
 #if defined(WEBRTC_WIN)
   DWORD key_;
@@ skipping 56 matching lines @@
   bool IsCurrent() const {
     return Current() == this;
   }
 
   // Sleeps the calling thread for the specified number of milliseconds, during
   // which time no processing is performed. Returns false if sleeping was
   // interrupted by a signal (POSIX only).
   static bool SleepMs(int millis);
 
   // Sets the thread's name, for debugging. Must be called before Start().
-  // If |obj| is non-NULL, its value is appended to |name|.
+  // If |obj| is non-null, its value is appended to |name|.
   const std::string& name() const { return name_; }
   bool SetName(const std::string& name, const void* obj);
 
   // Starts the execution of the thread.
-  bool Start(Runnable* runnable = NULL);
+  bool Start(Runnable* runnable = nullptr);
 
   // Tells the thread to stop and waits until it is joined.
   // Never call Stop on the current thread.  Instead use the inherited Quit
   // function which will exit the base MessageQueue without terminating the
   // underlying OS thread.
   virtual void Stop();
 
   // By default, Thread::Run() calls ProcessMessages(kForever).  To do other
   // work, override Run().  To receive and dispatch messages, call
   // ProcessMessages occasionally.
   virtual void Run();
 
   virtual void Send(const Location& posted_from,
                     MessageHandler* phandler,
                     uint32_t id = 0,
-                    MessageData* pdata = NULL);
+                    MessageData* pdata = nullptr);
 
   // Convenience method to invoke a functor on another thread.  Caller must
   // provide the |ReturnT| template argument, which cannot (easily) be deduced.
   // Uses Send() internally, which blocks the current thread until execution
   // is complete.
   // Ex: bool result = thread.Invoke<bool>(RTC_FROM_HERE,
   // &MyFunctionReturningBool);
   // NOTE: This function can only be called when synchronous calls are allowed.
   // See ScopedDisallowBlockingCalls for details.
   template <class ReturnT, class FunctorT>
   ReturnT Invoke(const Location& posted_from, const FunctorT& functor) {
     FunctorMessageHandler<ReturnT, FunctorT> handler(functor);
     InvokeInternal(posted_from, &handler);
     return handler.MoveResult();
   }
 
   // From MessageQueue
   void Clear(MessageHandler* phandler,
              uint32_t id = MQID_ANY,
-             MessageList* removed = NULL) override;
+             MessageList* removed = nullptr) override;
   void ReceiveSends() override;
 
   // ProcessMessages will process I/O and dispatch messages until:
   //  1) cms milliseconds have elapsed (returns true)
   //  2) Stop() is called (returns false)
   bool ProcessMessages(int cms);
 
   // Returns true if this is a thread that we created using the standard
   // constructor, false if it was created by a call to
   // ThreadManager::WrapCurrentThread().  The main thread of an application
@@ skipping 60 matching lines @@
   // ThreadManager::Instance() cannot be used while ThreadManager is
   // being created.
   // The method tries to get synchronization rights of the thread on Windows if
   // |need_synchronize_access| is true.
   bool WrapCurrentWithThreadManager(ThreadManager* thread_manager,
                                     bool need_synchronize_access);
 
   // Return true if the thread was started and hasn't yet stopped.
   bool running() { return running_.Wait(0); }
 
-  // Processes received "Send" requests. If |source| is not NULL, only requests
+  // Processes received "Send" requests. If |source| is not null, only requests
   // from |source| are processed, otherwise, all requests are processed.
   void ReceiveSendsFromThread(const Thread* source);
 
-  // If |source| is not NULL, pops the first "Send" message from |source| in
+  // If |source| is not null, pops the first "Send" message from |source| in
   // |sendlist_|, otherwise, pops the first "Send" message of |sendlist_|.
   // The caller must lock |crit_| before calling.
   // Returns true if there is such a message.
   bool PopSendMessageFromThread(const Thread* source, _SendMessage* msg);
 
   void InvokeInternal(const Location& posted_from, MessageHandler* handler);
 
   std::list<_SendMessage> sendlist_;
   std::string name_;
   Event running_;  // Signalled means running.
@@ skipping 56 matching lines @@
 
  private:
   SocketServer* old_ss_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(SocketServerScope);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_THREAD_H_