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

webrtc/base/virtualsocketserver.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 46 matching lines @@
   MSG_ID_CONNECT,
   MSG_ID_DISCONNECT,
 };
 
 // Packets are passed between sockets as messages.  We copy the data just like
 // the kernel does.
 class Packet : public MessageData {
  public:
   Packet(const char* data, size_t size, const SocketAddress& from)
         : size_(size), consumed_(0), from_(from) {
-    RTC_DCHECK(NULL != data);
+    RTC_DCHECK(nullptr != data);
     data_ = new char[size_];
     memcpy(data_, data, size_);
   }
 
   ~Packet() override {
     delete[] data_;
   }
 
   const char* data() const { return data_ + consumed_; }
   size_t size() const { return size_ - consumed_; }
@@ skipping 18 matching lines @@
 
 VirtualSocket::VirtualSocket(VirtualSocketServer* server,
                              int family,
                              int type,
                              bool async)
     : server_(server),
       type_(type),
       async_(async),
       state_(CS_CLOSED),
       error_(0),
-      listen_queue_(NULL),
+      listen_queue_(nullptr),
       network_size_(0),
       recv_buffer_size_(0),
       bound_(false),
       was_any_(false) {
   RTC_DCHECK((type_ == SOCK_DGRAM) || (type_ == SOCK_STREAM));
   RTC_DCHECK(async_ ||
              (type_ != SOCK_STREAM));  // We only support async streams
   server->SignalReadyToSend.connect(this,
                                     &VirtualSocket::OnSocketServerReadyToSend);
 }
@@ skipping 60 matching lines @@
     // Cancel pending sockets
     if (listen_queue_) {
       while (!listen_queue_->empty()) {
         SocketAddress addr = listen_queue_->front();
 
         // Disconnect listening socket.
         server_->Disconnect(server_->LookupBinding(addr));
         listen_queue_->pop_front();
       }
       delete listen_queue_;
-      listen_queue_ = NULL;
+      listen_queue_ = nullptr;
     }
     // Disconnect stream sockets
     if (CS_CONNECTED == state_) {
       // Disconnect remote socket, check if it is a child of a server socket.
       VirtualSocket* socket =
           server_->LookupConnection(local_addr_, remote_addr_);
       if (!socket) {
         // Not a server socket child, then see if it is bound.
         // TODO(tbd): If this is indeed a server socket that has no
         // children this will cause the server socket to be
         // closed. This might lead to unexpected results, how to fix this?
         socket = server_->LookupBinding(remote_addr_);
       }
       server_->Disconnect(socket);
 
       // Remove mapping for both directions.
       server_->RemoveConnection(remote_addr_, local_addr_);
       server_->RemoveConnection(local_addr_, remote_addr_);
     }
     // Cancel potential connects
     MessageList msgs;
     if (server_->msg_queue_) {
       server_->msg_queue_->Clear(this, MSG_ID_CONNECT, &msgs);
     }
     for (MessageList::iterator it = msgs.begin(); it != msgs.end(); ++it) {
-      RTC_DCHECK(NULL != it->pdata);
+      RTC_DCHECK(nullptr != it->pdata);
       MessageAddress* data = static_cast<MessageAddress*>(it->pdata);
 
       // Lookup remote side.
       VirtualSocket* socket =
           server_->LookupConnection(local_addr_, data->addr);
       if (socket) {
         // Server socket, remote side is a socket retreived by
         // accept. Accepted sockets are not bound so we will not
         // find it by looking in the bindings table.
         server_->Disconnect(socket);
@@ skipping 77 matching lines @@
   } else {
     recv_buffer_.pop_front();
     delete packet;
   }
 
   if (SOCK_STREAM == type_) {
     bool was_full = (recv_buffer_size_ == server_->recv_buffer_capacity_);
     recv_buffer_size_ -= data_read;
     if (was_full) {
       VirtualSocket* sender = server_->LookupBinding(remote_addr_);
-      RTC_DCHECK(NULL != sender);
+      RTC_DCHECK(nullptr != sender);
       server_->SendTcp(sender);
     }
   }
 
   return static_cast<int>(data_read);
 }
 
 int VirtualSocket::Listen(int backlog) {
   RTC_DCHECK(SOCK_STREAM == type_);
   RTC_DCHECK(CS_CLOSED == state_);
   if (local_addr_.IsNil()) {
     error_ = EINVAL;
     return -1;
   }
-  RTC_DCHECK(NULL == listen_queue_);
+  RTC_DCHECK(nullptr == listen_queue_);
   listen_queue_ = new ListenQueue;
   state_ = CS_CONNECTING;
   return 0;
 }
 
 VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
-  if (NULL == listen_queue_) {
+  if (nullptr == listen_queue_) {
     error_ = EINVAL;
-    return NULL;
+    return nullptr;
   }
   while (!listen_queue_->empty()) {
     VirtualSocket* socket = new VirtualSocket(server_, AF_INET, type_, async_);
 
     // Set the new local address to the same as this server socket.
     socket->SetLocalAddress(local_addr_);
     // Sockets made from a socket that 'was Any' need to inherit that.
     socket->set_was_any(was_any_);
     SocketAddress remote_addr(listen_queue_->front());
     int result = socket->InitiateConnect(remote_addr, false);
     listen_queue_->pop_front();
     if (result != 0) {
       delete socket;
       continue;
     }
     socket->CompleteConnect(remote_addr, false);
     if (paddr) {
       *paddr = remote_addr;
     }
     return socket;
   }
   error_ = EWOULDBLOCK;
-  return NULL;
+  return nullptr;
 }
 
 int VirtualSocket::GetError() const {
   return error_;
 }
 
 void VirtualSocket::SetError(int error) {
   error_ = error;
 }
 
@@ skipping 17 matching lines @@
 
 int VirtualSocket::EstimateMTU(uint16_t* mtu) {
   if (CS_CONNECTED != state_)
     return ENOTCONN;
   else
     return 65536;
 }
 
 void VirtualSocket::OnMessage(Message* pmsg) {
   if (pmsg->message_id == MSG_ID_PACKET) {
-    RTC_DCHECK(NULL != pmsg->pdata);
+    RTC_DCHECK(nullptr != pmsg->pdata);
     Packet* packet = static_cast<Packet*>(pmsg->pdata);
 
     recv_buffer_.push_back(packet);
 
     if (async_) {
       SignalReadEvent(this);
     }
   } else if (pmsg->message_id == MSG_ID_CONNECT) {
-    RTC_DCHECK(NULL != pmsg->pdata);
+    RTC_DCHECK(nullptr != pmsg->pdata);
     MessageAddress* data = static_cast<MessageAddress*>(pmsg->pdata);
-    if (listen_queue_ != NULL) {
+    if (listen_queue_ != nullptr) {
       listen_queue_->push_back(data->addr);
       if (async_) {
         SignalReadEvent(this);
       }
     } else if ((SOCK_STREAM == type_) && (CS_CONNECTING == state_)) {
       CompleteConnect(data->addr, true);
     } else {
       LOG(LS_VERBOSE) << "Socket at " << local_addr_ << " is not listening";
       server_->Disconnect(server_->LookupBinding(data->addr));
     }
@@ skipping 100 matching lines @@
     RTC_DCHECK(type_ == SOCK_STREAM);
     // This will attempt to empty the full send buffer, and will fire
     // SignalWriteEvent if successful.
     server_->SendTcp(this);
   }
 }
 
 VirtualSocketServer::VirtualSocketServer(SocketServer* ss)
     : server_(ss),
       server_owned_(false),
-      msg_queue_(NULL),
+      msg_queue_(nullptr),
       stop_on_idle_(false),
       next_ipv4_(kInitialNextIPv4),
       next_ipv6_(kInitialNextIPv6),
       next_port_(kFirstEphemeralPort),
       bindings_(new AddressMap()),
       connections_(new ConnectionMap()),
       bandwidth_(0),
       network_capacity_(kDefaultNetworkCapacity),
       send_buffer_capacity_(kDefaultTcpBufferSize),
       recv_buffer_capacity_(kDefaultTcpBufferSize),
@@ skipping 124 matching lines @@
   socket->SignalCloseEvent(socket, 0);
 
   // Trigger the remote connection's close event.
   socket->Close();
 
   return true;
 }
 
 int VirtualSocketServer::Bind(VirtualSocket* socket,
                               const SocketAddress& addr) {
-  RTC_DCHECK(NULL != socket);
+  RTC_DCHECK(nullptr != socket);
   // Address must be completely specified at this point
   RTC_DCHECK(!IPIsUnspec(addr.ipaddr()));
   RTC_DCHECK(addr.port() != 0);
 
   // Normalize the address (turns v6-mapped addresses into v4-addresses).
   SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
 
   AddressMap::value_type entry(normalized, socket);
   return bindings_->insert(entry).second ? 0 : -1;
 }
 
 int VirtualSocketServer::Bind(VirtualSocket* socket, SocketAddress* addr) {
-  RTC_DCHECK(NULL != socket);
+  RTC_DCHECK(nullptr != socket);
 
   if (!IPIsUnspec(addr->ipaddr())) {
     addr->SetIP(addr->ipaddr().Normalized());
   } else {
     RTC_NOTREACHED();
   }
 
   if (addr->port() == 0) {
     for (int i = 0; i < kEphemeralPortCount; ++i) {
       addr->SetPort(GetNextPort());
@@ skipping 53 matching lines @@
 
 VirtualSocket* VirtualSocketServer::LookupConnection(
     const SocketAddress& local,
     const SocketAddress& remote) {
   SocketAddress local_normalized(local.ipaddr().Normalized(),
                                  local.port());
   SocketAddress remote_normalized(remote.ipaddr().Normalized(),
                                   remote.port());
   SocketAddressPair address_pair(local_normalized, remote_normalized);
   ConnectionMap::iterator it = connections_->find(address_pair);
-  return (connections_->end() != it) ? it->second : NULL;
+  return (connections_->end() != it) ? it->second : nullptr;
 }
 
 void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
                                            const SocketAddress& remote) {
   SocketAddress local_normalized(local.ipaddr().Normalized(),
                                 local.port());
   SocketAddress remote_normalized(remote.ipaddr().Normalized(),
                                  remote.port());
   SocketAddressPair address_pair(local_normalized, remote_normalized);
   connections_->erase(address_pair);
 }
 
 static double Random() {
   return static_cast<double>(rand()) / RAND_MAX;
 }
 
 int VirtualSocketServer::Connect(VirtualSocket* socket,
                                  const SocketAddress& remote_addr,
                                  bool use_delay) {
   uint32_t delay = use_delay ? GetTransitDelay(socket) : 0;
   VirtualSocket* remote = LookupBinding(remote_addr);
   if (!CanInteractWith(socket, remote)) {
     LOG(LS_INFO) << "Address family mismatch between "
                  << socket->GetLocalAddress() << " and " << remote_addr;
     return -1;
   }
-  if (remote != NULL) {
+  if (remote != nullptr) {
     SocketAddress addr = socket->GetLocalAddress();
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, remote, MSG_ID_CONNECT,
                             new MessageAddress(addr));
   } else {
     LOG(LS_INFO) << "No one listening at " << remote_addr;
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, socket, MSG_ID_DISCONNECT);
   }
   return 0;
 }
 
@@ skipping 392 matching lines @@
 void VirtualSocketServer::SetDefaultRoute(const IPAddress& from_addr) {
   RTC_DCHECK(!IPIsAny(from_addr));
   if (from_addr.family() == AF_INET) {
     default_route_v4_ = from_addr;
   } else if (from_addr.family() == AF_INET6) {
     default_route_v6_ = from_addr;
   }
 }
 
 }  // namespace rtc