Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/turnport.cc

 /*
  *  Copyright 2012 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 181 matching lines @@
     : Port(thread,
            RELAY_PORT_TYPE,
            factory,
            network,
            socket->GetLocalAddress().ipaddr(),
            username,
            password),
       server_address_(server_address),
       credentials_(credentials),
       socket_(socket),
-      resolver_(NULL),
+      resolver_(nullptr),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
       state_(STATE_CONNECTING),
       server_priority_(server_priority),
       allocate_mismatch_retries_(0) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
@@ skipping 13 matching lines @@
            RELAY_PORT_TYPE,
            factory,
            network,
            ip,
            min_port,
            max_port,
            username,
            password),
       server_address_(server_address),
       credentials_(credentials),
-      socket_(NULL),
-      resolver_(NULL),
+      socket_(nullptr),
+      resolver_(nullptr),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
       state_(STATE_CONNECTING),
       server_priority_(server_priority),
       allocate_mismatch_retries_(0) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
   request_manager_.set_origin(origin);
 }
 
@@ skipping 186 matching lines @@
   }
 
   LOG_J(LS_INFO, this) << "Allocating a new socket after "
                        << "STUN_ERROR_ALLOCATION_MISMATCH, retry = "
                        << allocate_mismatch_retries_ + 1;
   if (SharedSocket()) {
     ResetSharedSocket();
   } else {
     delete socket_;
   }
-  socket_ = NULL;
+  socket_ = nullptr;
 
   ResetNonce();
   PrepareAddress();
   ++allocate_mismatch_retries_;
 }
 
 Connection* TurnPort::CreateConnection(const Candidate& remote_candidate,
                                        CandidateOrigin origin) {
   // TURN-UDP can only connect to UDP candidates.
   if (!SupportsProtocol(remote_candidate.protocol())) {
-    return NULL;
+    return nullptr;
   }
 
   if (state_ == STATE_DISCONNECTED || state_ == STATE_RECEIVEONLY) {
-    return NULL;
+    return nullptr;
   }
 
   // A TURN port will have two candiates, STUN and TURN. STUN may not
   // present in all cases. If present stun candidate will be added first
   // and TURN candidate later.
   for (size_t index = 0; index < Candidates().size(); ++index) {
     const Candidate& local_candidate = Candidates()[index];
     if (local_candidate.type() == RELAY_PORT_TYPE &&
         local_candidate.address().family() ==
             remote_candidate.address().family()) {
       // Create an entry, if needed, so we can get our permissions set up
       // correctly.
       CreateOrRefreshEntry(remote_candidate.address());
       ProxyConnection* conn =
           new ProxyConnection(this, index, remote_candidate);
       AddOrReplaceConnection(conn);
       return conn;
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 bool TurnPort::FailAndPruneConnection(const rtc::SocketAddress& address) {
   Connection* conn = GetConnection(address);
   if (conn != nullptr) {
     conn->FailAndPrune();
     return true;
   }
   return false;
 }
@@ skipping 310 matching lines @@
         // Send another allocate request to alternate server, with the received
         // realm and nonce values.
         SendRequest(new TurnAllocateRequest(this), 0);
       } else {
         // Since it's TCP, we have to delete the connected socket and reconnect
         // with the alternate server. PrepareAddress will send stun binding once
         // the new socket is connected.
         RTC_DCHECK(server_address().proto == PROTO_TCP);
         RTC_DCHECK(!SharedSocket());
         delete socket_;
-        socket_ = NULL;
+        socket_ = nullptr;
         PrepareAddress();
       }
       break;
     default:
       Port::OnMessage(message);
   }
 }
 
 void TurnPort::OnAllocateRequestTimeout() {
   OnAllocateError();
@@ skipping 165 matching lines @@
   return (std::find_if(entries_.begin(), entries_.end(),
       std::bind2nd(std::ptr_fun(MatchesIP), ipaddr)) != entries_.end());
 }
 
 static bool MatchesAddress(TurnEntry* e, rtc::SocketAddress addr) {
   return e->address() == addr;
 }
 TurnEntry* TurnPort::FindEntry(const rtc::SocketAddress& addr) const {
   EntryList::const_iterator it = std::find_if(entries_.begin(), entries_.end(),
       std::bind2nd(std::ptr_fun(MatchesAddress), addr));
-  return (it != entries_.end()) ? *it : NULL;
+  return (it != entries_.end()) ? *it : nullptr;
 }
 
 static bool MatchesChannelId(TurnEntry* e, int id) {
   return e->channel_id() == id;
 }
 TurnEntry* TurnPort::FindEntry(int channel_id) const {
   EntryList::const_iterator it = std::find_if(entries_.begin(), entries_.end(),
       std::bind2nd(std::ptr_fun(MatchesChannelId), channel_id));
-  return (it != entries_.end()) ? *it : NULL;
+  return (it != entries_.end()) ? *it : nullptr;
 }
 
 bool TurnPort::EntryExists(TurnEntry* e) {
   auto it = std::find(entries_.begin(), entries_.end(), e);
   return it != entries_.end();
 }
 
 void TurnPort::CreateOrRefreshEntry(const rtc::SocketAddress& addr) {
   TurnEntry* entry = FindEntry(addr);
   if (entry == nullptr) {
     entry = new TurnEntry(this, next_channel_number_++, addr);
     entries_.push_back(entry);
   } else {
     // The channel binding request for the entry will be refreshed automatically
     // until the entry is destroyed.
     CancelEntryDestruction(entry);
   }
 }
 
 void TurnPort::DestroyEntry(TurnEntry* entry) {
-  RTC_DCHECK(entry != NULL);
+  RTC_DCHECK(entry != nullptr);
   entry->SignalDestroyed(entry);
   entries_.remove(entry);
   delete entry;
 }
 
 void TurnPort::DestroyEntryIfNotCancelled(TurnEntry* entry, int64_t timestamp) {
   if (!EntryExists(entry)) {
     return;
   }
   bool cancelled = timestamp != entry->destruction_timestamp();
   if (!cancelled) {
     DestroyEntry(entry);
   }
 }
 
 void TurnPort::HandleConnectionDestroyed(Connection* conn) {
   // Schedule an event to destroy TurnEntry for the connection, which is
   // already destroyed.
   const rtc::SocketAddress& remote_address = conn->remote_candidate().address();
   TurnEntry* entry = FindEntry(remote_address);
-  RTC_DCHECK(entry != NULL);
+  RTC_DCHECK(entry != nullptr);
   ScheduleEntryDestruction(entry);
 }
 
 void TurnPort::ScheduleEntryDestruction(TurnEntry* entry) {
   RTC_DCHECK(entry->destruction_timestamp() == 0);
   int64_t timestamp = rtc::TimeMillis();
   entry->set_destruction_timestamp(timestamp);
   invoker_.AsyncInvokeDelayed<void>(
       RTC_FROM_HERE, thread(),
       rtc::Bind(&TurnPort::DestroyEntryIfNotCancelled, this, entry, timestamp),
@@ skipping 306 matching lines @@
 void TurnCreatePermissionRequest::OnTimeout() {
   LOG_J(LS_WARNING, port_) << "TURN create permission timeout "
                            << rtc::hex_encode(id());
   if (entry_) {
     entry_->OnCreatePermissionTimeout();
   }
 }
 
 void TurnCreatePermissionRequest::OnEntryDestroyed(TurnEntry* entry) {
   RTC_DCHECK(entry_ == entry);
-  entry_ = NULL;
+  entry_ = nullptr;
 }
 
 TurnChannelBindRequest::TurnChannelBindRequest(
     TurnPort* port, TurnEntry* entry,
     int channel_id, const rtc::SocketAddress& ext_addr)
     : StunRequest(new TurnMessage()),
       port_(port),
       entry_(entry),
       channel_id_(channel_id),
       ext_addr_(ext_addr) {
@@ skipping 49 matching lines @@
 void TurnChannelBindRequest::OnTimeout() {
   LOG_J(LS_WARNING, port_) << "TURN channel bind timeout "
                            << rtc::hex_encode(id());
   if (entry_) {
     entry_->OnChannelBindTimeout();
   }
 }
 
 void TurnChannelBindRequest::OnEntryDestroyed(TurnEntry* entry) {
   RTC_DCHECK(entry_ == entry);
-  entry_ = NULL;
+  entry_ = nullptr;
 }
 
 TurnEntry::TurnEntry(TurnPort* port, int channel_id,
                      const rtc::SocketAddress& ext_addr)
     : port_(port),
       channel_id_(channel_id),
       ext_addr_(ext_addr),
       state_(STATE_UNBOUND) {
   // Creating permission for |ext_addr_|.
   SendCreatePermissionRequest(0);
@@ skipping 97 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->FailAndPruneConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->FailAndPruneConnection(ext_addr_);
 }
 }  // namespace cricket