Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/natsocketfactory.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 53 matching lines @@
     return kNATEncodedIPv6AddressSize;
   }
   return 0U;
 }
 
 
 // NATSocket
 class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
  public:
   explicit NATSocket(NATInternalSocketFactory* sf, int family, int type)
-      : sf_(sf), family_(family), type_(type), connected_(false),
-        socket_(NULL), buf_(NULL), size_(0) {
-  }
+      : sf_(sf),
+        family_(family),
+        type_(type),
+        connected_(false),
+        socket_(nullptr),
+        buf_(nullptr),
+        size_(0) {}
 
   ~NATSocket() override {
     delete socket_;
     delete[] buf_;
   }
 
   SocketAddress GetLocalAddress() const override {
     return (socket_) ? socket_->GetLocalAddress() : SocketAddress();
   }
 
@@ skipping 10 matching lines @@
     socket_ = sf_->CreateInternalSocket(family_, type_, addr, &server_addr_);
     result = (socket_) ? socket_->Bind(addr) : -1;
     if (result >= 0) {
       socket_->SignalConnectEvent.connect(this, &NATSocket::OnConnectEvent);
       socket_->SignalReadEvent.connect(this, &NATSocket::OnReadEvent);
       socket_->SignalWriteEvent.connect(this, &NATSocket::OnWriteEvent);
       socket_->SignalCloseEvent.connect(this, &NATSocket::OnCloseEvent);
     } else {
       server_addr_.Clear();
       delete socket_;
-      socket_ = NULL;
+      socket_ = nullptr;
     }
 
     return result;
   }
 
   int Connect(const SocketAddress& addr) override {
     if (!socket_) {  // socket must be bound, for now
       return -1;
     }
 
@@ skipping 86 matching lines @@
   }
 
   int Close() override {
     int result = 0;
     if (socket_) {
       result = socket_->Close();
       if (result >= 0) {
         connected_ = false;
         remote_addr_ = SocketAddress();
         delete socket_;
-        socket_ = NULL;
+        socket_ = nullptr;
       }
     }
     return result;
   }
 
   int Listen(int backlog) override { return socket_->Listen(backlog); }
   AsyncSocket* Accept(SocketAddress* paddr) override {
     return socket_->Accept(paddr);
   }
   int GetError() const override { return socket_->GetError(); }
@@ skipping 107 matching lines @@
   if (type == SOCK_STREAM) {
     *nat_addr = nat_tcp_addr_;
   } else {
     *nat_addr = nat_udp_addr_;
   }
   return factory_->CreateAsyncSocket(family, type);
 }
 
 // NATSocketServer
 NATSocketServer::NATSocketServer(SocketServer* server)
-    : server_(server), msg_queue_(NULL) {
-}
+    : server_(server), msg_queue_(nullptr) {}
 
 NATSocketServer::Translator* NATSocketServer::GetTranslator(
     const SocketAddress& ext_ip) {
   return nats_.Get(ext_ip);
 }
 
 NATSocketServer::Translator* NATSocketServer::AddTranslator(
     const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
   // Fail if a translator already exists with this extternal address.
   if (nats_.Get(ext_ip))
-    return NULL;
+    return nullptr;
 
   return nats_.Add(ext_ip, new Translator(this, type, int_ip, server_, ext_ip));
 }
 
 void NATSocketServer::RemoveTranslator(
     const SocketAddress& ext_ip) {
   nats_.Remove(ext_ip);
 }
 
 Socket* NATSocketServer::CreateSocket(int type) {
@@ skipping 20 matching lines @@
 bool NATSocketServer::Wait(int cms, bool process_io) {
   return server_->Wait(cms, process_io);
 }
 
 void NATSocketServer::WakeUp() {
   server_->WakeUp();
 }
 
 AsyncSocket* NATSocketServer::CreateInternalSocket(int family, int type,
     const SocketAddress& local_addr, SocketAddress* nat_addr) {
-  AsyncSocket* socket = NULL;
+  AsyncSocket* socket = nullptr;
   Translator* nat = nats_.FindClient(local_addr);
   if (nat) {
     socket = nat->internal_factory()->CreateAsyncSocket(family, type);
     *nat_addr = (type == SOCK_STREAM) ?
         nat->internal_tcp_address() : nat->internal_udp_address();
   } else {
     socket = server_->CreateAsyncSocket(family, type);
   }
   return socket;
 }
@@ skipping 17 matching lines @@
 
 NATSocketServer::Translator* NATSocketServer::Translator::GetTranslator(
     const SocketAddress& ext_ip) {
   return nats_.Get(ext_ip);
 }
 
 NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
     const SocketAddress& ext_ip, const SocketAddress& int_ip, NATType type) {
   // Fail if a translator already exists with this extternal address.
   if (nats_.Get(ext_ip))
-    return NULL;
+    return nullptr;
 
   AddClient(ext_ip);
   return nats_.Add(ext_ip,
                    new Translator(server_, type, int_ip, server_, ext_ip));
 }
 void NATSocketServer::Translator::RemoveTranslator(
     const SocketAddress& ext_ip) {
   nats_.Remove(ext_ip);
   RemoveClient(ext_ip);
 }
@@ skipping 26 matching lines @@
 // NATSocketServer::TranslatorMap
 NATSocketServer::TranslatorMap::~TranslatorMap() {
   for (TranslatorMap::iterator it = begin(); it != end(); ++it) {
     delete it->second;
   }
 }
 
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::Get(
     const SocketAddress& ext_ip) {
   TranslatorMap::iterator it = find(ext_ip);
-  return (it != end()) ? it->second : NULL;
+  return (it != end()) ? it->second : nullptr;
 }
 
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::Add(
     const SocketAddress& ext_ip, Translator* nat) {
   (*this)[ext_ip] = nat;
   return nat;
 }
 
 void NATSocketServer::TranslatorMap::Remove(
     const SocketAddress& ext_ip) {
   TranslatorMap::iterator it = find(ext_ip);
   if (it != end()) {
     delete it->second;
     erase(it);
   }
 }
 
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
     const SocketAddress& int_ip) {
-  Translator* nat = NULL;
+  Translator* nat = nullptr;
   for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
     nat = it->second->FindClient(int_ip);
   }
   return nat;
 }
 
 }  // namespace rtc