Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/port.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 167 matching lines @@
       max_port_(max_port),
       component_(ICE_CANDIDATE_COMPONENT_DEFAULT),
       generation_(0),
       ice_username_fragment_(username_fragment),
       password_(password),
       timeout_delay_(kPortTimeoutDelay),
       enable_port_packets_(false),
       ice_role_(ICEROLE_UNKNOWN),
       tiebreaker_(0),
       shared_socket_(false) {
-  RTC_DCHECK(factory_ != NULL);
+  RTC_DCHECK(factory_ != nullptr);
   Construct();
 }
 
 void Port::Construct() {
   // TODO(pthatcher): Remove this old behavior once we're sure no one
   // relies on it.  If the username_fragment and password are empty,
   // we should just create one.
   if (ice_username_fragment_.empty()) {
     RTC_DCHECK(password_.empty());
     ice_username_fragment_ = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
@@ skipping 34 matching lines @@
     c.set_username(username_fragment);
     c.set_password(password);
   }
 }
 
 Connection* Port::GetConnection(const rtc::SocketAddress& remote_addr) {
   AddressMap::const_iterator iter = connections_.find(remote_addr);
   if (iter != connections_.end())
     return iter->second;
   else
-    return NULL;
+    return nullptr;
 }
 
 void Port::AddAddress(const rtc::SocketAddress& address,
                       const rtc::SocketAddress& base_address,
                       const rtc::SocketAddress& related_address,
                       const std::string& protocol,
                       const std::string& relay_protocol,
                       const std::string& tcptype,
                       const std::string& type,
                       uint32_t type_preference,
@@ skipping 95 matching lines @@
 }
 
 bool Port::GetStunMessage(const char* data,
                           size_t size,
                           const rtc::SocketAddress& addr,
                           std::unique_ptr<IceMessage>* out_msg,
                           std::string* out_username) {
   // NOTE: This could clearly be optimized to avoid allocating any memory.
   //       However, at the data rates we'll be looking at on the client side,
   //       this probably isn't worth worrying about.
-  RTC_DCHECK(out_msg != NULL);
-  RTC_DCHECK(out_username != NULL);
+  RTC_DCHECK(out_msg != nullptr);
+  RTC_DCHECK(out_username != nullptr);
   out_username->clear();
 
   // Don't bother parsing the packet if we can tell it's not STUN.
   // In ICE mode, all STUN packets will have a valid fingerprint.
   if (!StunMessage::ValidateFingerprint(data, size)) {
     return false;
   }
 
   // Parse the request message.  If the packet is not a complete and correct
   // STUN message, then ignore it.
@@ skipping 91 matching lines @@
 bool Port::ParseStunUsername(const StunMessage* stun_msg,
                              std::string* local_ufrag,
                              std::string* remote_ufrag) const {
   // The packet must include a username that either begins or ends with our
   // fragment.  It should begin with our fragment if it is a request and it
   // should end with our fragment if it is a response.
   local_ufrag->clear();
   remote_ufrag->clear();
   const StunByteStringAttribute* username_attr =
         stun_msg->GetByteString(STUN_ATTR_USERNAME);
-  if (username_attr == NULL)
+  if (username_attr == nullptr)
     return false;
 
   // RFRAG:LFRAG
   const std::string username = username_attr->GetString();
   size_t colon_pos = username.find(":");
   if (colon_pos == std::string::npos) {
     return false;
   }
 
   *local_ufrag = username.substr(0, colon_pos);
@@ skipping 70 matching lines @@
   stun_username_attr_str->append(username_fragment());
 }
 
 void Port::SendBindingResponse(StunMessage* request,
                                const rtc::SocketAddress& addr) {
   RTC_DCHECK(request->type() == STUN_BINDING_REQUEST);
 
   // Retrieve the username from the request.
   const StunByteStringAttribute* username_attr =
       request->GetByteString(STUN_ATTR_USERNAME);
-  RTC_DCHECK(username_attr != NULL);
-  if (username_attr == NULL) {
+  RTC_DCHECK(username_attr != nullptr);
+  if (username_attr == nullptr) {
     // No valid username, skip the response.
     return;
   }
 
   // Fill in the response message.
   StunMessage response;
   response.SetType(STUN_BINDING_RESPONSE);
   response.SetTransactionID(request->transaction_id());
   const StunUInt32Attribute* retransmit_attr =
       request->GetUInt32(STUN_ATTR_RETRANSMIT_COUNT);
@@ skipping 1013 matching lines @@
     RTC_DCHECK(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket