Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/stun.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 388 matching lines @@
   StunAttributeValueType value_type = GetAttributeValueType(type);
   return StunAttribute::Create(value_type, type, static_cast<uint16_t>(length),
                                this);
 }
 
 const StunAttribute* StunMessage::GetAttribute(int type) const {
   for (size_t i = 0; i < attrs_->size(); ++i) {
     if ((*attrs_)[i]->type() == type)
       return (*attrs_)[i];
   }
-  return NULL;
+  return nullptr;
 }
 
 bool StunMessage::IsValidTransactionId(const std::string& transaction_id) {
   return transaction_id.size() == kStunTransactionIdLength ||
       transaction_id.size() == kStunLegacyTransactionIdLength;
 }
 
 // StunAttribute
 
 StunAttribute::StunAttribute(uint16_t type, uint16_t length)
@@ skipping 28 matching lines @@
       return new StunUInt32Attribute(type);
     case STUN_VALUE_UINT64:
       return new StunUInt64Attribute(type);
     case STUN_VALUE_BYTE_STRING:
       return new StunByteStringAttribute(type, length);
     case STUN_VALUE_ERROR_CODE:
       return new StunErrorCodeAttribute(type, length);
     case STUN_VALUE_UINT16_LIST:
       return new StunUInt16ListAttribute(type, length);
     default:
-      return NULL;
+      return nullptr;
   }
 }
 
 StunAddressAttribute* StunAttribute::CreateAddress(uint16_t type) {
   return new StunAddressAttribute(type, 0);
 }
 
 StunXorAddressAttribute* StunAttribute::CreateXorAddress(uint16_t type) {
-  return new StunXorAddressAttribute(type, 0, NULL);
+  return new StunXorAddressAttribute(type, 0, nullptr);
 }
 
 StunUInt64Attribute* StunAttribute::CreateUInt64(uint16_t type) {
   return new StunUInt64Attribute(type);
 }
 
 StunUInt32Attribute* StunAttribute::CreateUInt32(uint16_t type) {
   return new StunUInt32Attribute(type);
 }
 
@@ skipping 77 matching lines @@
       in6_addr v6addr = address_.ipaddr().ipv6_address();
       buf->WriteBytes(reinterpret_cast<char*>(&v6addr), sizeof(v6addr));
       break;
     }
   }
   return true;
 }
 
 StunXorAddressAttribute::StunXorAddressAttribute(uint16_t type,
                                                  const rtc::SocketAddress& addr)
-    : StunAddressAttribute(type, addr), owner_(NULL) {
-}
+    : StunAddressAttribute(type, addr), owner_(nullptr) {}
 
 StunXorAddressAttribute::StunXorAddressAttribute(uint16_t type,
                                                  uint16_t length,
                                                  StunMessage* owner)
     : StunAddressAttribute(type, length), owner_(owner) {
 }
 
 rtc::IPAddress StunXorAddressAttribute::GetXoredIP() const {
   if (owner_) {
     rtc::IPAddress ip = ipaddr();
@@ skipping 110 matching lines @@
     return false;
   return true;
 }
 
 bool StunUInt64Attribute::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt64(bits_);
   return true;
 }
 
 StunByteStringAttribute::StunByteStringAttribute(uint16_t type)
-    : StunAttribute(type, 0), bytes_(NULL) {
-}
+    : StunAttribute(type, 0), bytes_(nullptr) {}
 
 StunByteStringAttribute::StunByteStringAttribute(uint16_t type,
                                                  const std::string& str)
-    : StunAttribute(type, 0), bytes_(NULL) {
+    : StunAttribute(type, 0), bytes_(nullptr) {
   CopyBytes(str.c_str(), str.size());
 }
 
 StunByteStringAttribute::StunByteStringAttribute(uint16_t type,
                                                  const void* bytes,
                                                  size_t length)
-    : StunAttribute(type, 0), bytes_(NULL) {
+    : StunAttribute(type, 0), bytes_(nullptr) {
   CopyBytes(bytes, length);
 }
 
 StunByteStringAttribute::StunByteStringAttribute(uint16_t type, uint16_t length)
-    : StunAttribute(type, length), bytes_(NULL) {
-}
+    : StunAttribute(type, length), bytes_(nullptr) {}
 
 StunByteStringAttribute::~StunByteStringAttribute() {
   delete [] bytes_;
 }
 
 void StunByteStringAttribute::CopyBytes(const char* bytes) {
   CopyBytes(bytes, strlen(bytes));
 }
 
 void StunByteStringAttribute::CopyBytes(const void* bytes, size_t length) {
   char* new_bytes = new char[length];
   memcpy(new_bytes, bytes, length);
   SetBytes(new_bytes, length);
 }
 
 uint8_t StunByteStringAttribute::GetByte(size_t index) const {
-  RTC_DCHECK(bytes_ != NULL);
+  RTC_DCHECK(bytes_ != nullptr);
   RTC_DCHECK(index < length());
   return static_cast<uint8_t>(bytes_[index]);
 }
 
 void StunByteStringAttribute::SetByte(size_t index, uint8_t value) {
-  RTC_DCHECK(bytes_ != NULL);
+  RTC_DCHECK(bytes_ != nullptr);
   RTC_DCHECK(index < length());
   bytes_[index] = value;
 }
 
 bool StunByteStringAttribute::Read(ByteBufferReader* buf) {
   bytes_ = new char[length()];
   if (!buf->ReadBytes(bytes_, length())) {
     return false;
   }
 
@@ skipping 163 matching lines @@
       digest, sizeof(digest));
   if (size == 0) {
     return false;
   }
 
   *hash = std::string(digest, size);
   return true;
 }
 
 }  // namespace cricket