Replace NULL with nullptr in all C++ files.

webrtc/p2p/base/turnserver.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 100 matching lines @@
   int resp_type = (req) ? GetStunErrorResponseType(req->type()) : -1;
   if (resp_type == -1)
     return false;
   resp->SetType(resp_type);
   resp->SetTransactionID(req->transaction_id());
   resp->AddAttribute(new cricket::StunErrorCodeAttribute(
       STUN_ATTR_ERROR_CODE, code, reason));
   return true;
 }
 
-
 TurnServer::TurnServer(rtc::Thread* thread)
     : thread_(thread),
       nonce_key_(rtc::CreateRandomString(kNonceKeySize)),
-      auth_hook_(NULL),
-      redirect_hook_(NULL),
-      enable_otu_nonce_(false) {
-}
+      auth_hook_(nullptr),
+      redirect_hook_(nullptr),
+      enable_otu_nonce_(false) {}
 
 TurnServer::~TurnServer() {
   for (InternalSocketMap::iterator it = server_sockets_.begin();
        it != server_sockets_.end(); ++it) {
     rtc::AsyncPacketSocket* socket = it->first;
     delete socket;
   }
 
   for (ServerSocketMap::iterator it = server_listen_sockets_.begin();
        it != server_listen_sockets_.end(); ++it) {
@@ skipping 27 matching lines @@
 void TurnServer::OnNewInternalConnection(rtc::AsyncSocket* socket) {
   RTC_DCHECK(server_listen_sockets_.find(socket) !=
              server_listen_sockets_.end());
   AcceptConnection(socket);
 }
 
 void TurnServer::AcceptConnection(rtc::AsyncSocket* server_socket) {
   // Check if someone is trying to connect to us.
   rtc::SocketAddress accept_addr;
   rtc::AsyncSocket* accepted_socket = server_socket->Accept(&accept_addr);
-  if (accepted_socket != NULL) {
+  if (accepted_socket != nullptr) {
     ProtocolType proto = server_listen_sockets_[server_socket];
     cricket::AsyncStunTCPSocket* tcp_socket =
         new cricket::AsyncStunTCPSocket(accepted_socket, false);
 
     tcp_socket->SignalClose.connect(this, &TurnServer::OnInternalSocketClose);
     // Finally add the socket so it can start communicating with the client.
     AddInternalSocket(tcp_socket, proto);
   }
 }
 
@@ skipping 34 matching lines @@
     LOG(LS_WARNING) << "Received invalid STUN message";
     return;
   }
 
   // If it's a STUN binding request, handle that specially.
   if (msg.type() == STUN_BINDING_REQUEST) {
     HandleBindingRequest(conn, &msg);
     return;
   }
 
-  if (redirect_hook_ != NULL && msg.type() == STUN_ALLOCATE_REQUEST) {
+  if (redirect_hook_ != nullptr && msg.type() == STUN_ALLOCATE_REQUEST) {
     rtc::SocketAddress address;
     if (redirect_hook_->ShouldRedirect(conn->src(), &address)) {
       SendErrorResponseWithAlternateServer(
           conn, &msg, address);
       return;
     }
   }
 
   // Look up the key that we'll use to validate the M-I. If we have an
   // existing allocation, the key will already be cached.
@@ skipping 35 matching lines @@
 }
 
 bool TurnServer::GetKey(const StunMessage* msg, std::string* key) {
   const StunByteStringAttribute* username_attr =
       msg->GetByteString(STUN_ATTR_USERNAME);
   if (!username_attr) {
     return false;
   }
 
   std::string username = username_attr->GetString();
-  return (auth_hook_ != NULL && auth_hook_->GetKey(username, realm_, key));
+  return (auth_hook_ != nullptr && auth_hook_->GetKey(username, realm_, key));
 }
 
 bool TurnServer::CheckAuthorization(TurnServerConnection* conn,
                                     const StunMessage* msg,
                                     const char* data, size_t size,
                                     const std::string& key) {
   // RFC 5389, 10.2.2.
   RTC_DCHECK(IsStunRequestType(msg->type()));
   const StunByteStringAttribute* mi_attr =
       msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
@@ skipping 130 matching lines @@
 }
 
 TurnServerAllocation* TurnServer::FindAllocation(TurnServerConnection* conn) {
   AllocationMap::const_iterator it = allocations_.find(*conn);
   return (it != allocations_.end()) ? it->second.get() : nullptr;
 }
 
 TurnServerAllocation* TurnServer::CreateAllocation(TurnServerConnection* conn,
                                                    int proto,
                                                    const std::string& key) {
-  rtc::AsyncPacketSocket* external_socket = (external_socket_factory_) ?
-      external_socket_factory_->CreateUdpSocket(external_addr_, 0, 0) : NULL;
+  rtc::AsyncPacketSocket* external_socket =
+      (external_socket_factory_)
+          ? external_socket_factory_->CreateUdpSocket(external_addr_, 0, 0)
+          : nullptr;
   if (!external_socket) {
-    return NULL;
+    return nullptr;
   }
 
   // The Allocation takes ownership of the socket.
   TurnServerAllocation* allocation = new TurnServerAllocation(this,
       thread_, *conn, external_socket, key);
   allocation->SignalDestroyed.connect(this, &TurnServer::OnAllocationDestroyed);
   allocations_[*conn].reset(allocation);
   return allocation;
 }
 
@@ skipping 144 matching lines @@
   LOG_J(LS_INFO, this) << "Allocation destroyed";
 }
 
 std::string TurnServerAllocation::ToString() const {
   std::ostringstream ost;
   ost << "Alloc[" << conn_.ToString() << "]";
   return ost.str();
 }
 
 void TurnServerAllocation::HandleTurnMessage(const TurnMessage* msg) {
-  RTC_DCHECK(msg != NULL);
+  RTC_DCHECK(msg != nullptr);
   switch (msg->type()) {
     case STUN_ALLOCATE_REQUEST:
       HandleAllocateRequest(msg);
       break;
     case TURN_REFRESH_REQUEST:
       HandleRefreshRequest(msg);
       break;
     case TURN_SEND_INDICATION:
       HandleSendIndication(msg);
       break;
     case TURN_CREATE_PERMISSION_REQUEST:
       HandleCreatePermissionRequest(msg);
       break;
     case TURN_CHANNEL_BIND_REQUEST:
       HandleChannelBindRequest(msg);
       break;
     default:
       // Not sure what to do with this, just eat it.
       LOG_J(LS_WARNING, this) << "Invalid TURN message type received: "
                               << msg->type();
   }
 }
 
 void TurnServerAllocation::HandleAllocateRequest(const TurnMessage* msg) {
   // Copy the important info from the allocate request.
   transaction_id_ = msg->transaction_id();
   const StunByteStringAttribute* username_attr =
       msg->GetByteString(STUN_ATTR_USERNAME);
-  RTC_DCHECK(username_attr != NULL);
+  RTC_DCHECK(username_attr != nullptr);
   username_ = username_attr->GetString();
   const StunByteStringAttribute* origin_attr =
       msg->GetByteString(STUN_ATTR_ORIGIN);
   if (origin_attr) {
     origin_ = origin_attr->GetString();
   }
 
   // Figure out the lifetime and start the allocation timer.
   int lifetime_secs = ComputeLifetime(msg);
   thread_->PostDelayed(RTC_FROM_HERE, lifetime_secs * 1000, this,
@@ skipping 188 matching lines @@
   // Return the smaller of our default lifetime and the requested lifetime.
   int lifetime = kDefaultAllocationTimeout / 1000;  // convert to seconds
   const StunUInt32Attribute* lifetime_attr = msg->GetUInt32(STUN_ATTR_LIFETIME);
   if (lifetime_attr && static_cast<int>(lifetime_attr->value()) < lifetime) {
     lifetime = static_cast<int>(lifetime_attr->value());
   }
   return lifetime;
 }
 
 bool TurnServerAllocation::HasPermission(const rtc::IPAddress& addr) {
-  return (FindPermission(addr) != NULL);
+  return (FindPermission(addr) != nullptr);
 }
 
 void TurnServerAllocation::AddPermission(const rtc::IPAddress& addr) {
   Permission* perm = FindPermission(addr);
   if (!perm) {
     perm = new Permission(thread_, addr);
     perm->SignalDestroyed.connect(
         this, &TurnServerAllocation::OnPermissionDestroyed);
     perms_.push_back(perm);
   } else {
     perm->Refresh();
   }
 }
 
 TurnServerAllocation::Permission* TurnServerAllocation::FindPermission(
     const rtc::IPAddress& addr) const {
   for (PermissionList::const_iterator it = perms_.begin();
        it != perms_.end(); ++it) {
     if ((*it)->peer() == addr)
       return *it;
   }
-  return NULL;
+  return nullptr;
 }
 
 TurnServerAllocation::Channel* TurnServerAllocation::FindChannel(
     int channel_id) const {
   for (ChannelList::const_iterator it = channels_.begin();
        it != channels_.end(); ++it) {
     if ((*it)->id() == channel_id)
       return *it;
   }
-  return NULL;
+  return nullptr;
 }
 
 TurnServerAllocation::Channel* TurnServerAllocation::FindChannel(
     const rtc::SocketAddress& addr) const {
   for (ChannelList::const_iterator it = channels_.begin();
        it != channels_.end(); ++it) {
     if ((*it)->peer() == addr)
       return *it;
   }
-  return NULL;
+  return nullptr;
 }
 
 void TurnServerAllocation::SendResponse(TurnMessage* msg) {
   // Success responses always have M-I.
   msg->AddMessageIntegrity(key_);
   server_->SendStun(&conn_, msg);
 }
 
 void TurnServerAllocation::SendBadRequestResponse(const TurnMessage* req) {
   SendErrorResponse(req, STUN_ERROR_BAD_REQUEST, STUN_ERROR_REASON_BAD_REQUEST);
@@ skipping 67 matching lines @@
                        MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::OnMessage(rtc::Message* msg) {
   RTC_DCHECK(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 }  // namespace cricket