Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/p2ptransportchannel.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 771 matching lines @@
     }
   }
 
   // If this candidate matches what was thought to be a peer reflexive
   // candidate, we need to update the candidate priority/etc.
   for (Connection* conn : connections_) {
     conn->MaybeUpdatePeerReflexiveCandidate(new_remote_candidate);
   }
 
   // Create connections to this remote candidate.
-  CreateConnections(new_remote_candidate, NULL);
+  CreateConnections(new_remote_candidate, nullptr);
 
   // Resort the connections list, which may have new elements.
   SortConnectionsAndUpdateState();
 }
 
 void P2PTransportChannel::RemoveRemoteCandidate(
     const Candidate& cand_to_remove) {
   auto iter =
       std::remove_if(remote_candidates_.begin(), remote_candidates_.end(),
                      [cand_to_remove](const Candidate& candidate) {
@@ skipping 12 matching lines @@
                                             PortInterface* origin_port) {
   RTC_DCHECK(network_thread_ == rtc::Thread::Current());
 
   // If we've already seen the new remote candidate (in the current candidate
   // generation), then we shouldn't try creating connections for it.
   // We either already have a connection for it, or we previously created one
   // and then later pruned it. If we don't return, the channel will again
   // re-create any connections that were previously pruned, which will then
   // immediately be re-pruned, churning the network for no purpose.
   // This only applies to candidates received over signaling (i.e. origin_port
-  // is NULL).
+  // is null).
   if (!origin_port && IsDuplicateRemoteCandidate(remote_candidate)) {
     // return true to indicate success, without creating any new connections.
     return true;
   }
 
   // Add a new connection for this candidate to every port that allows such a
   // connection (i.e., if they have compatible protocols) and that does not
   // already have a connection to an equivalent candidate.  We must be careful
   // to make sure that the origin port is included, even if it was pruned,
   // since that may be the only port that can create this connection.
   bool created = false;
   std::vector<PortInterface *>::reverse_iterator it;
   for (it = ports_.rbegin(); it != ports_.rend(); ++it) {
     if (CreateConnection(*it, remote_candidate, origin_port)) {
       if (*it == origin_port)
         created = true;
     }
   }
 
-  if ((origin_port != NULL) &&
+  if ((origin_port != nullptr) &&
       std::find(ports_.begin(), ports_.end(), origin_port) == ports_.end()) {
     if (CreateConnection(origin_port, remote_candidate, origin_port))
       created = true;
   }
 
   // Remember this remote candidate so that we can add it to future ports.
   RememberRemoteCandidate(remote_candidate, origin_port);
 
   return created;
 }
@@ skipping 506 matching lines @@
     if (best_conn_on_network && conn != best_conn_on_network &&
         !best_conn_on_network->weak() &&
         CompareConnectionCandidates(best_conn_on_network, conn) >= 0) {
       conn->Prune();
     }
   }
 }
 
 // Change the selected connection, and let listeners know.
 void P2PTransportChannel::SwitchSelectedConnection(Connection* conn) {
-  // Note: if conn is NULL, the previous |selected_connection_| has been
+  // Note: if conn is null, the previous |selected_connection_| has been
   // destroyed, so don't use it.
   Connection* old_selected_connection = selected_connection_;
   selected_connection_ = conn;
   if (selected_connection_) {
     ++nomination_;
     if (old_selected_connection) {
       LOG_J(LS_INFO, this) << "Previous selected connection: "
                            << old_selected_connection->ToString();
     }
     LOG_J(LS_INFO, this) << "New selected connection: "
@@ skipping 666 matching lines @@
 
 void P2PTransportChannel::set_receiving(bool receiving) {
   if (receiving_ == receiving) {
     return;
   }
   receiving_ = receiving;
   SignalReceivingState(this);
 }
 
 }  // namespace cricket