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

webrtc/base/messagequeue.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 139 matching lines @@
 
 const uint32_t MQID_ANY = static_cast<uint32_t>(-1);
 const uint32_t MQID_DISPOSE = static_cast<uint32_t>(-2);
 
 // No destructor
 
 struct Message {
   Message()
       : phandler(nullptr), message_id(0), pdata(nullptr), ts_sensitive(0) {}
   inline bool Match(MessageHandler* handler, uint32_t id) const {
-    return (handler == NULL || handler == phandler)
-           && (id == MQID_ANY || id == message_id);
+    return (handler == nullptr || handler == phandler) &&
+           (id == MQID_ANY || id == message_id);
   }
   Location posted_from;
   MessageHandler *phandler;
   uint32_t message_id;
   MessageData *pdata;
   int64_t ts_sensitive;
 };
 
 typedef std::list<Message> MessageList;
 
@@ skipping 57 matching lines @@
   // Get() will process I/O until:
   //  1) A message is available (returns true)
   //  2) cmsWait seconds have elapsed (returns false)
   //  3) Stop() is called (returns false)
   virtual bool Get(Message *pmsg, int cmsWait = kForever,
                    bool process_io = true);
   virtual bool Peek(Message *pmsg, int cmsWait = 0);
   virtual void Post(const Location& posted_from,
                     MessageHandler* phandler,
                     uint32_t id = 0,
-                    MessageData* pdata = NULL,
+                    MessageData* pdata = nullptr,
                     bool time_sensitive = false);
   virtual void PostDelayed(const Location& posted_from,
                            int cmsDelay,
                            MessageHandler* phandler,
                            uint32_t id = 0,
-                           MessageData* pdata = NULL);
+                           MessageData* pdata = nullptr);
   virtual void PostAt(const Location& posted_from,
                       int64_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
-                      MessageData* pdata = NULL);
+                      MessageData* pdata = nullptr);
   // TODO(honghaiz): Remove this when all the dependencies are removed.
   virtual void PostAt(const Location& posted_from,
                       uint32_t tstamp,
                       MessageHandler* phandler,
                       uint32_t id = 0,
-                      MessageData* pdata = NULL);
+                      MessageData* pdata = nullptr);
   virtual void Clear(MessageHandler* phandler,
                      uint32_t id = MQID_ANY,
-                     MessageList* removed = NULL);
+                     MessageList* removed = nullptr);
   virtual void Dispatch(Message *pmsg);
   virtual void ReceiveSends();
 
   // Amount of time until the next message can be retrieved
   virtual int GetDelay();
 
   bool empty() const { return size() == 0u; }
   size_t size() const {
     CritScope cs(&crit_);  // msgq_.size() is not thread safe.
     return msgq_.size() + dmsgq_.size() + (fPeekKeep_ ? 1u : 0u);
   }
 
   // Internally posts a message which causes the doomed object to be deleted
   template<class T> void Dispose(T* doomed) {
     if (doomed) {
-      Post(RTC_FROM_HERE, NULL, MQID_DISPOSE, new DisposeData<T>(doomed));
+      Post(RTC_FROM_HERE, nullptr, MQID_DISPOSE, new DisposeData<T>(doomed));
     }
   }
 
   // When this signal is sent out, any references to this queue should
   // no longer be used.
   sigslot::signal0<> SignalQueueDestroyed;
 
  protected:
   class PriorityQueue : public std::priority_queue<DelayedMessage> {
    public:
@@ skipping 35 matching lines @@
   // Used if SocketServer ownership lies with |this|.
   std::unique_ptr<SocketServer> own_ss_;
   SharedExclusiveLock ss_lock_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(MessageQueue);
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_MESSAGEQUEUE_H_