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

webrtc/base/asynctcpsocket.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 29 matching lines @@
 static const int kListenBacklog = 5;
 
 // Binds and connects |socket|
 AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
     rtc::AsyncSocket* socket,
     const rtc::SocketAddress& bind_address,
     const rtc::SocketAddress& remote_address) {
   std::unique_ptr<rtc::AsyncSocket> owned_socket(socket);
   if (socket->Bind(bind_address) < 0) {
     LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
-    return NULL;
+    return nullptr;
   }
   if (socket->Connect(remote_address) < 0) {
     LOG(LS_ERROR) << "Connect() failed with error " << socket->GetError();
-    return NULL;
+    return nullptr;
   }
   return owned_socket.release();
 }
 
 AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket, bool listen,
                                        size_t max_packet_size)
     : socket_(socket),
       listen_(listen),
       max_insize_(max_packet_size),
       max_outsize_(max_packet_size) {
   if (!listen_) {
     // Listening sockets don't send/receive data, so they don't need buffers.
     inbuf_.EnsureCapacity(kMinimumRecvSize);
   }
 
-  RTC_DCHECK(socket_.get() != NULL);
+  RTC_DCHECK(socket_.get() != nullptr);
   socket_->SignalConnectEvent.connect(
       this, &AsyncTCPSocketBase::OnConnectEvent);
   socket_->SignalReadEvent.connect(this, &AsyncTCPSocketBase::OnReadEvent);
   socket_->SignalWriteEvent.connect(this, &AsyncTCPSocketBase::OnWriteEvent);
   socket_->SignalCloseEvent.connect(this, &AsyncTCPSocketBase::OnCloseEvent);
 
   if (listen_) {
     if (socket_->Listen(kListenBacklog) < 0) {
       LOG(LS_ERROR) << "Listen() failed with error " << socket_->GetError();
     }
@@ skipping 172 matching lines @@
     SignalReadyToSend(this);
   }
 }
 
 void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
   SignalClose(this, error);
 }
 
 // AsyncTCPSocket
 // Binds and connects |socket| and creates AsyncTCPSocket for
-// it. Takes ownership of |socket|. Returns NULL if bind() or
+// it. Takes ownership of |socket|. Returns null if bind() or
 // connect() fail (|socket| is destroyed in that case).
 AsyncTCPSocket* AsyncTCPSocket::Create(
     AsyncSocket* socket,
     const SocketAddress& bind_address,
     const SocketAddress& remote_address) {
   return new AsyncTCPSocket(AsyncTCPSocketBase::ConnectSocket(
       socket, bind_address, remote_address), false);
 }
 
 AsyncTCPSocket::AsyncTCPSocket(AsyncSocket* socket, bool listen)
@@ skipping 48 matching lines @@
       memmove(data, data + kPacketLenSize + pkt_len, *len);
     }
   }
 }
 
 void AsyncTCPSocket::HandleIncomingConnection(AsyncSocket* socket) {
   SignalNewConnection(this, new AsyncTCPSocket(socket, false));
 }
 
 }  // namespace rtc