Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/tcpport.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 74 matching lines @@
            LOCAL_PORT_TYPE,
            factory,
            network,
            ip,
            min_port,
            max_port,
            username,
            password),
       incoming_only_(false),
       allow_listen_(allow_listen),
-      socket_(NULL),
+      socket_(nullptr),
       error_(0) {
   // TODO(mallinath) - Set preference value as per RFC 6544.
   // http://b/issue?id=7141794
 }
 
 bool TCPPort::Init() {
   if (allow_listen_) {
     // Treat failure to create or bind a TCP socket as fatal.  This
     // should never happen.
     socket_ = socket_factory()->CreateServerTcpSocket(
@@ skipping 13 matching lines @@
   delete socket_;
   std::list<Incoming>::iterator it;
   for (it = incoming_.begin(); it != incoming_.end(); ++it)
     delete it->socket;
   incoming_.clear();
 }
 
 Connection* TCPPort::CreateConnection(const Candidate& address,
                                       CandidateOrigin origin) {
   if (!SupportsProtocol(address.protocol())) {
-    return NULL;
+    return nullptr;
   }
 
   if (address.tcptype() == TCPTYPE_ACTIVE_STR ||
       (address.tcptype().empty() && address.address().port() == 0)) {
     // It's active only candidate, we should not try to create connections
     // for these candidates.
-    return NULL;
+    return nullptr;
   }
 
   // We can't accept TCP connections incoming on other ports
   if (origin == ORIGIN_OTHER_PORT)
-    return NULL;
+    return nullptr;
 
   // Check if we are allowed to make outgoing TCP connections
   if (incoming_only_ && (origin == ORIGIN_MESSAGE))
-    return NULL;
+    return nullptr;
 
   // We don't know how to act as an ssl server yet
   if ((address.protocol() == SSLTCP_PROTOCOL_NAME) &&
       (origin == ORIGIN_THIS_PORT)) {
-    return NULL;
+    return nullptr;
   }
 
   if (!IsCompatibleAddress(address.address())) {
-    return NULL;
+    return nullptr;
   }
 
-  TCPConnection* conn = NULL;
+  TCPConnection* conn = nullptr;
   if (rtc::AsyncPacketSocket* socket =
       GetIncoming(address.address(), true)) {
     socket->SignalReadPacket.disconnect(this);
     conn = new TCPConnection(this, address, socket);
   } else {
     conn = new TCPConnection(this, address);
   }
   AddOrReplaceConnection(conn);
   return conn;
 }
@@ skipping 21 matching lines @@
                rtc::SocketAddress(ip(), 0), rtc::SocketAddress(),
                TCP_PROTOCOL_NAME, "", TCPTYPE_ACTIVE_STR, LOCAL_PORT_TYPE,
                ICE_TYPE_PREFERENCE_HOST_TCP, 0, true);
   }
 }
 
 int TCPPort::SendTo(const void* data, size_t size,
                     const rtc::SocketAddress& addr,
                     const rtc::PacketOptions& options,
                     bool payload) {
-  rtc::AsyncPacketSocket * socket = NULL;
+  rtc::AsyncPacketSocket* socket = nullptr;
   TCPConnection* conn = static_cast<TCPConnection*>(GetConnection(addr));
 
   // For Connection, this is the code path used by Ping() to establish
   // WRITABLE. It has to send through the socket directly as TCPConnection::Send
   // checks writability.
   if (conn) {
     if (!conn->connected()) {
       conn->MaybeReconnect();
       return SOCKET_ERROR;
     }
@@ skipping 50 matching lines @@
   incoming.socket->SignalReadyToSend.connect(this, &TCPPort::OnReadyToSend);
   incoming.socket->SignalSentPacket.connect(this, &TCPPort::OnSentPacket);
 
   LOG_J(LS_VERBOSE, this) << "Accepted connection from "
                           << incoming.addr.ToSensitiveString();
   incoming_.push_back(incoming);
 }
 
 rtc::AsyncPacketSocket* TCPPort::GetIncoming(
     const rtc::SocketAddress& addr, bool remove) {
-  rtc::AsyncPacketSocket* socket = NULL;
+  rtc::AsyncPacketSocket* socket = nullptr;
   for (std::list<Incoming>::iterator it = incoming_.begin();
        it != incoming_.end(); ++it) {
     if (it->addr == addr) {
       socket = it->socket;
       if (remove)
         incoming_.erase(it);
       break;
     }
   }
   return socket;
@@ skipping 21 matching lines @@
              TCPTYPE_PASSIVE_STR, LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST_TCP,
              0, true);
 }
 
 TCPConnection::TCPConnection(TCPPort* port,
                              const Candidate& candidate,
                              rtc::AsyncPacketSocket* socket)
     : Connection(port, 0, candidate),
       socket_(socket),
       error_(0),
-      outgoing_(socket == NULL),
+      outgoing_(socket == nullptr),
       connection_pending_(false),
       pretending_to_be_writable_(false),
       reconnection_timeout_(cricket::CONNECTION_WRITE_CONNECT_TIMEOUT) {
   if (outgoing_) {
     CreateOutgoingTcpSocket();
   } else {
     // Incoming connections should match the network address.
     LOG_J(LS_VERBOSE, this)
         << "socket ipaddr: " << socket_->GetLocalAddress().ToString()
         << ",port() ip:" << port->ip().ToString();
@@ skipping 189 matching lines @@
 void TCPConnection::ConnectSocketSignals(rtc::AsyncPacketSocket* socket) {
   if (outgoing_) {
     socket->SignalConnect.connect(this, &TCPConnection::OnConnect);
   }
   socket->SignalReadPacket.connect(this, &TCPConnection::OnReadPacket);
   socket->SignalReadyToSend.connect(this, &TCPConnection::OnReadyToSend);
   socket->SignalClose.connect(this, &TCPConnection::OnClose);
 }
 
 }  // namespace cricket