Replace NULL with nullptr in all C++ files.

webrtc/base/autodetectproxy.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 12 matching lines @@
 static const int kSavedStringLimit = 128;
 
 static void SaveStringToStack(char *dst,
                               const std::string &src,
                               size_t dst_size) {
   strncpy(dst, src.c_str(), dst_size - 1);
   dst[dst_size - 1] = '\0';
 }
 
 AutoDetectProxy::AutoDetectProxy(const std::string& user_agent)
-    : agent_(user_agent), resolver_(NULL), socket_(NULL), next_(0) {
-}
+    : agent_(user_agent), resolver_(nullptr), socket_(nullptr), next_(0) {}
 
 bool AutoDetectProxy::GetProxyForUrl(const char* agent,
                                      const char* url,
                                      rtc::ProxyInfo* proxy) {
   return GetProxySettingsForUrl(agent, url, proxy, true);
 }
 
 AutoDetectProxy::~AutoDetectProxy() {
   if (resolver_) {
     resolver_->Destroy(false);
@@ skipping 92 matching lines @@
   if (error == 0) {
     LOG(LS_VERBOSE) << "Resolved " << proxy_.address << " to "
                     << resolver_->address();
     proxy_.address = resolver_->address();
     if (!DoConnect()) {
       Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TIMEOUT);
     }
   } else {
     LOG(LS_INFO) << "Failed to resolve " << resolver_->address();
     resolver_->Destroy(false);
-    resolver_ = NULL;
+    resolver_ = nullptr;
     proxy_.address = SocketAddress();
     Thread::Current()->Post(RTC_FROM_HERE, this, MSG_UNRESOLVABLE);
   }
 }
 
 void AutoDetectProxy::Next() {
   if (TEST_ORDER[next_] >= PROXY_UNKNOWN) {
     Complete(PROXY_UNKNOWN);
     return;
   }
 
   LOG(LS_VERBOSE) << "AutoDetectProxy connecting to "
                   << proxy_.address.ToSensitiveString();
 
   if (socket_) {
     Thread::Current()->Clear(this, MSG_TIMEOUT);
     Thread::Current()->Clear(this, MSG_UNRESOLVABLE);
     socket_->Close();
     Thread::Current()->Dispose(socket_);
-    socket_ = NULL;
+    socket_ = nullptr;
   }
   int timeout = 2000;
   if (proxy_.address.IsUnresolvedIP()) {
     // Launch an asyncresolver. This thread will spin waiting for it.
     timeout += 2000;
     if (!resolver_) {
       resolver_ = new AsyncResolver();
     }
     resolver_->SignalDone.connect(this, &AutoDetectProxy::OnResolveResult);
     resolver_->Start(proxy_.address);
   } else {
     if (!DoConnect()) {
       Thread::Current()->Post(RTC_FROM_HERE, this, MSG_TIMEOUT);
       return;
     }
   }
   Thread::Current()->PostDelayed(RTC_FROM_HERE, timeout, this, MSG_TIMEOUT);
 }
 
 bool AutoDetectProxy::DoConnect() {
   if (resolver_) {
     resolver_->Destroy(false);
-    resolver_ = NULL;
+    resolver_ = nullptr;
   }
   socket_ =
       Thread::Current()->socketserver()->CreateAsyncSocket(
           proxy_.address.family(), SOCK_STREAM);
   if (!socket_) {
     LOG(LS_VERBOSE) << "Unable to create socket for " << proxy_.address;
     return false;
   }
   socket_->SignalConnectEvent.connect(this, &AutoDetectProxy::OnConnectEvent);
   socket_->SignalReadEvent.connect(this, &AutoDetectProxy::OnReadEvent);
@@ skipping 92 matching lines @@
   Next();
 }
 
 void AutoDetectProxy::OnCloseEvent(AsyncSocket * socket, int error) {
   LOG(LS_VERBOSE) << "AutoDetectProxy closed with error: " << error;
   ++next_;
   Next();
 }
 
 }  // namespace rtc