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

webrtc/base/win32socketserver.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 147 matching lines @@
   virtual void OnNcDestroy();
 
  private:
   bool OnSocketNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& result);
   bool OnDnsNotify(WPARAM wParam, LPARAM lParam, LRESULT& result);
 
   Win32Socket * parent_;
 };
 
 void Win32Socket::EventSink::Dispose() {
-  parent_ = NULL;
+  parent_ = nullptr;
   if (::IsWindow(handle())) {
     ::DestroyWindow(handle());
   } else {
     delete this;
   }
 }
 
 bool Win32Socket::EventSink::OnMessage(UINT uMsg, WPARAM wParam,
                                        LPARAM lParam, LRESULT& result) {
   switch (uMsg) {
@@ skipping 41 matching lines @@
   } else {
     delete this;
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Win32Socket
 /////////////////////////////////////////////////////////////////////////////
 
 Win32Socket::Win32Socket()
-    : socket_(INVALID_SOCKET), error_(0), state_(CS_CLOSED), connect_time_(0),
-      closing_(false), close_error_(0), sink_(NULL), dns_(NULL) {
-}
+    : socket_(INVALID_SOCKET),
+      error_(0),
+      state_(CS_CLOSED),
+      connect_time_(0),
+      closing_(false),
+      close_error_(0),
+      sink_(nullptr),
+      dns_(nullptr) {}
 
 Win32Socket::~Win32Socket() {
   Close();
 }
 
 bool Win32Socket::CreateT(int family, int type) {
   Close();
   int proto = (SOCK_DGRAM == type) ? IPPROTO_UDP : IPPROTO_TCP;
-  socket_ = ::WSASocket(family, type, proto, NULL, NULL, 0);
+  socket_ = ::WSASocket(family, type, proto, nullptr, 0, 0);
   if (socket_ == INVALID_SOCKET) {
     UpdateLastError();
     return false;
   }
   if ((SOCK_DGRAM == type) && !SetAsync(FD_READ | FD_WRITE)) {
     return false;
   }
   return true;
 }
 
@@ skipping 228 matching lines @@
     state_ = CS_CONNECTING;
   return err;
 }
 
 Win32Socket* Win32Socket::Accept(SocketAddress* out_addr) {
   sockaddr_storage saddr;
   socklen_t addr_len = sizeof(saddr);
   SOCKET s = ::accept(socket_, reinterpret_cast<sockaddr*>(&saddr), &addr_len);
   UpdateLastError();
   if (s == INVALID_SOCKET)
-    return NULL;
+    return nullptr;
   if (out_addr)
     SocketAddressFromSockAddrStorage(saddr, out_addr);
   Win32Socket* socket = new Win32Socket;
   if (0 == socket->Attach(s))
     return socket;
   delete socket;
-  return NULL;
+  return nullptr;
 }
 
 int Win32Socket::Close() {
   int err = 0;
   if (socket_ != INVALID_SOCKET) {
     err = ::closesocket(socket_);
     socket_ = INVALID_SOCKET;
     closing_ = false;
     close_error_ = 0;
     UpdateLastError();
   }
   if (dns_) {
     WSACancelAsyncRequest(dns_->handle);
     delete dns_;
-    dns_ = NULL;
+    dns_ = nullptr;
   }
   if (sink_) {
     sink_->Dispose();
-    sink_ = NULL;
+    sink_ = nullptr;
   }
   addr_.Clear();
   state_ = CS_CLOSED;
   return err;
 }
 
 int Win32Socket::EstimateMTU(uint16_t* mtu) {
   SocketAddress addr = GetRemoteAddress();
   if (addr.IsAnyIP()) {
     error_ = ENOTCONN;
@@ skipping 18 matching lines @@
       *mtu = PACKET_MAXIMUMS[level];
       return 0;
     }
   }
 
   RTC_NOTREACHED();
   return 0;
 }
 
 void Win32Socket::CreateSink() {
-  RTC_DCHECK(NULL == sink_);
+  RTC_DCHECK(nullptr == sink_);
 
   // Create window
   sink_ = new EventSink(this);
-  sink_->Create(NULL, L"EventSink", 0, 0, 0, 0, 10, 10);
+  sink_->Create(nullptr, L"EventSink", 0, 0, 0, 0, 10, 10);
 }
 
 bool Win32Socket::SetAsync(int events) {
-  if (NULL == sink_) {
+  if (nullptr == sink_) {
     CreateSink();
-    RTC_DCHECK(NULL != sink_);
+    RTC_DCHECK(nullptr != sink_);
   }
 
   // start the async select
   if (WSAAsyncSelect(socket_, sink_->handle(), WM_SOCKETNOTIFY, events)
       == SOCKET_ERROR) {
     UpdateLastError();
     Close();
     return false;
   }
 
@@ skipping 126 matching lines @@
     error = DoConnect(address);
   } else {
     Close();
   }
 
   if (error) {
     error_ = error;
     SignalCloseEvent(this, error_);
   } else {
     delete dns_;
-    dns_ = NULL;
+    dns_ = nullptr;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Win32SocketServer
 // Provides cricket base services on top of a win32 gui thread
 ///////////////////////////////////////////////////////////////////////////////
 
 static UINT s_wm_wakeup_id = 0;
 const TCHAR Win32SocketServer::kWindowName[] = L"libjingle Message Window";
 
 Win32SocketServer::Win32SocketServer(MessageQueue* message_queue)
     : message_queue_(message_queue),
       wnd_(this),
       posted_(false),
-      hdlg_(NULL) {
+      hdlg_(nullptr) {
   if (s_wm_wakeup_id == 0)
     s_wm_wakeup_id = RegisterWindowMessage(L"WM_WAKEUP");
-  if (!wnd_.Create(NULL, kWindowName, 0, 0, 0, 0, 0, 0)) {
+  if (!wnd_.Create(nullptr, kWindowName, 0, 0, 0, 0, 0, 0)) {
     LOG_GLE(LS_ERROR) << "Failed to create message window.";
   }
 }
 
 Win32SocketServer::~Win32SocketServer() {
-  if (wnd_.handle() != NULL) {
+  if (wnd_.handle() != nullptr) {
     KillTimer(wnd_.handle(), 1);
     wnd_.Destroy();
   }
 }
 
 Socket* Win32SocketServer::CreateSocket(int type) {
   return CreateSocket(AF_INET, type);
 }
 
 Socket* Win32SocketServer::CreateSocket(int family, int type) {
   return CreateAsyncSocket(family, type);
 }
 
 AsyncSocket* Win32SocketServer::CreateAsyncSocket(int type) {
   return CreateAsyncSocket(AF_INET, type);
 }
 
 AsyncSocket* Win32SocketServer::CreateAsyncSocket(int family, int type) {
   Win32Socket* socket = new Win32Socket;
   if (socket->CreateT(family, type)) {
     return socket;
   }
   delete socket;
-  return NULL;
+  return nullptr;
 }
 
 void Win32SocketServer::SetMessageQueue(MessageQueue* queue) {
   message_queue_ = queue;
 }
 
 bool Win32SocketServer::Wait(int cms, bool process_io) {
   BOOL b;
   if (process_io) {
     // Spin the Win32 message pump at least once, and as long as requested.
     // This is the Thread::ProcessMessages case.
     uint32_t start = Time();
     do {
       MSG msg;
-      SetTimer(wnd_.handle(), 0, cms, NULL);
+      SetTimer(wnd_.handle(), 0, cms, nullptr);
       // Get the next available message. If we have a modeless dialog, give
       // give the message to IsDialogMessage, which will return true if it
       // was a message for the dialog that it handled internally.
       // Otherwise, dispatch as usual via Translate/DispatchMessage.
-      b = GetMessage(&msg, NULL, 0, 0);
+      b = GetMessage(&msg, nullptr, 0, 0);
       if (b == -1) {
         LOG_GLE(LS_ERROR) << "GetMessage failed.";
         return false;
       } else if(b) {
         if (!hdlg_ || !IsDialogMessage(hdlg_, &msg)) {
           TranslateMessage(&msg);
           DispatchMessage(&msg);
         }
       }
       KillTimer(wnd_.handle(), 0);
     } while (b && TimeSince(start) < cms);
   } else if (cms != 0) {
     // Sit and wait forever for a WakeUp. This is the Thread::Send case.
     RTC_DCHECK(cms == -1);
     MSG msg;
-    b = GetMessage(&msg, NULL, s_wm_wakeup_id, s_wm_wakeup_id);
+    b = GetMessage(&msg, nullptr, s_wm_wakeup_id, s_wm_wakeup_id);
     {
       CritScope scope(&cs_);
       posted_ = false;
     }
   } else {
     // No-op (cms == 0 && !process_io). This is the Pump case.
     b = TRUE;
   }
   return (b != FALSE);
 }
@@ skipping 29 matching lines @@
        max_messages_to_process > 0 && message_queue_->Get(&msg, 0, false);
        --max_messages_to_process) {
     message_queue_->Dispatch(&msg);
   }
 
   // Anything remaining?
   int delay = message_queue_->GetDelay();
   if (delay == -1) {
     KillTimer(wnd_.handle(), 1);
   } else {
-    SetTimer(wnd_.handle(), 1, delay, NULL);
+    SetTimer(wnd_.handle(), 1, delay, nullptr);
   }
 }
 
 bool Win32SocketServer::MessageWindow::OnMessage(UINT wm, WPARAM wp,
                                                  LPARAM lp, LRESULT& lr) {
   bool handled = false;
   if (wm == s_wm_wakeup_id || (wm == WM_TIMER && wp == 1)) {
     ss_->Pump();
     lr = 0;
     handled = true;
   }
   return handled;
 }
 
 }  // namespace rtc