Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/relayport.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.
  */
 #include <algorithm>
@@ skipping 237 matching lines @@
                  0, false);
     }
     ready_ = true;
     SignalPortComplete(this);
   }
 }
 
 const ProtocolAddress * RelayPort::ServerAddress(size_t index) const {
   if (index < server_addr_.size())
     return &server_addr_[index];
-  return NULL;
+  return nullptr;
 }
 
 bool RelayPort::HasMagicCookie(const char* data, size_t size) {
   if (size < 24 + sizeof(TURN_MAGIC_COOKIE_VALUE)) {
     return false;
   } else {
     return memcmp(data + 24,
                   TURN_MAGIC_COOKIE_VALUE,
                   sizeof(TURN_MAGIC_COOKIE_VALUE)) == 0;
   }
@@ skipping 173 matching lines @@
 
 int RelayConnection::Send(const void* pv, size_t cb,
                           const rtc::PacketOptions& options) {
   return socket_->SendTo(pv, cb, GetAddress(), options);
 }
 
 void RelayConnection::SendAllocateRequest(RelayEntry* entry, int delay) {
   request_manager_->SendDelayed(new AllocateRequest(entry, this), delay);
 }
 
-RelayEntry::RelayEntry(RelayPort* port,
-                       const rtc::SocketAddress& ext_addr)
-    : port_(port), ext_addr_(ext_addr),
-      server_index_(0), connected_(false), locked_(false),
-      current_connection_(NULL) {
-}
+RelayEntry::RelayEntry(RelayPort* port, const rtc::SocketAddress& ext_addr)
+    : port_(port),
+      ext_addr_(ext_addr),
+      server_index_(0),
+      connected_(false),
+      locked_(false),
+      current_connection_(nullptr) {}
 
 RelayEntry::~RelayEntry() {
   // Remove all RelayConnections and dispose sockets.
   delete current_connection_;
-  current_connection_ = NULL;
+  current_connection_ = nullptr;
 }
 
 void RelayEntry::Connect() {
   // If we're already connected, return.
   if (connected_)
     return;
 
   // If we've exhausted all options, bail out.
   const ProtocolAddress* ra = port()->ServerAddress(server_index_);
   if (!ra) {
     LOG(LS_WARNING) << "No more relay addresses left to try";
     return;
   }
 
   // Remove any previous connection.
   if (current_connection_) {
     port()->thread()->Dispose(current_connection_);
-    current_connection_ = NULL;
+    current_connection_ = nullptr;
   }
 
   // Try to set up our new socket.
   LOG(LS_INFO) << "Connecting to relay via " << ProtoToString(ra->proto) <<
       " @ " << ra->address.ToSensitiveString();
 
-  rtc::AsyncPacketSocket* socket = NULL;
+  rtc::AsyncPacketSocket* socket = nullptr;
 
   if (ra->proto == PROTO_UDP) {
     // UDP sockets are simple.
     socket = port_->socket_factory()->CreateUdpSocket(
         rtc::SocketAddress(port_->ip(), 0),
         port_->min_port(), port_->max_port());
   } else if (ra->proto == PROTO_TCP || ra->proto == PROTO_SSLTCP) {
     int opts = (ra->proto == PROTO_SSLTCP)
                    ? rtc::PacketSocketFactory::OPT_TLS_FAKE
                    : 0;
@@ skipping 30 matching lines @@
     socket->SignalClose.connect(this, &RelayEntry::OnSocketClose);
     socket->SignalConnect.connect(this, &RelayEntry::OnSocketConnect);
     port()->thread()->PostDelayed(RTC_FROM_HERE, kSoftConnectTimeoutMs, this,
                                   kMessageConnectTimeout);
   } else {
     current_connection_->SendAllocateRequest(this, 0);
   }
 }
 
 int RelayEntry::GetError() {
-  if (current_connection_ != NULL) {
+  if (current_connection_ != nullptr) {
     return current_connection_->GetError();
   }
   return 0;
 }
 
 RelayConnection* RelayEntry::GetBestConnection(RelayConnection* conn1,
                                                RelayConnection* conn2) {
   return conn1->GetProtocol() <= conn2->GetProtocol() ? conn1 : conn2;
 }
 
@@ skipping 106 matching lines @@
     // Currently we connect to each server address in sequence. If we
     // have more addresses to try, treat this is an error and move on to
     // the next address, otherwise give this connection more time and
     // await the real timeout.
     //
     // TODO: Connect to servers in parallel to speed up connect time
     // and to avoid giving up too early.
     port_->SignalSoftTimeout(ra);
     HandleConnectFailure(current_connection_->socket());
   } else {
-    HandleConnectFailure(NULL);
+    HandleConnectFailure(nullptr);
   }
 }
 
 void RelayEntry::OnSocketConnect(rtc::AsyncPacketSocket* socket) {
   LOG(INFO) << "relay tcp connected to " <<
       socket->GetRemoteAddress().ToSensitiveString();
-  if (current_connection_ != NULL) {
+  if (current_connection_ != nullptr) {
     current_connection_->SendAllocateRequest(this, 0);
   }
 }
 
 void RelayEntry::OnSocketClose(rtc::AsyncPacketSocket* socket,
                                int error) {
   PLOG(LERROR, error) << "Relay connection failed: socket closed";
   HandleConnectFailure(socket);
 }
 
 void RelayEntry::OnReadPacket(
     rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
     const rtc::SocketAddress& remote_addr,
     const rtc::PacketTime& packet_time) {
   // RTC_DCHECK(remote_addr == port_->server_addr());
   // TODO: are we worried about this?
 
-  if (current_connection_ == NULL || socket != current_connection_->socket()) {
+  if (current_connection_ == nullptr ||
+      socket != current_connection_->socket()) {
     // This packet comes from an unknown address.
     LOG(WARNING) << "Dropping packet: unknown address";
     return;
   }
 
   // If the magic cookie is not present, then this is an unwrapped packet sent
   // by the server,  The actual remote address is the one we recorded.
   if (!port_->HasMagicCookie(data, size)) {
     if (locked_) {
       port_->OnReadPacket(data, size, ext_addr_, PROTO_UDP, packet_time);
@@ skipping 137 matching lines @@
   if (rtc::TimeMillis() - start_time_ <= kRetryTimeout)
     entry_->ScheduleKeepAlive();
 }
 
 void AllocateRequest::OnTimeout() {
   LOG(INFO) << "Allocate request timed out";
   entry_->HandleConnectFailure(connection_->socket());
 }
 
 }  // namespace cricket