Replace NULL with nullptr in WebSocket code in net/socket/

net/socket/websocket_transport_client_socket_pool.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/websocket_transport_client_socket_pool.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 269 matching lines @@
 WebSocketTransportClientSocketPool::WebSocketTransportClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     NetLog* net_log)
     : TransportClientSocketPool(max_sockets,
                                 max_sockets_per_group,
                                 host_resolver,
                                 client_socket_factory,
-                                NULL,
+                                nullptr,
                                 net_log),
       connect_job_delegate_(this),
       pool_net_log_(net_log),
       client_socket_factory_(client_socket_factory),
       host_resolver_(host_resolver),
       max_sockets_(max_sockets),
       handed_out_socket_count_(0),
       flushing_(false),
       weak_factory_(this) {}
 
@@ skipping 122 matching lines @@
   // then OnConnectJobComplete(). The |flushing_| flag tells this object to
   // ignore spurious calls to OnConnectJobComplete(). It is safe to ignore those
   // calls because this method will delete the jobs and call their callbacks
   // anyway.
   flushing_ = true;
   for (PendingConnectsMap::iterator it = pending_connects_.begin();
        it != pending_connects_.end();
        ++it) {
     InvokeUserCallbackLater(
         it->second->handle(), it->second->callback(), error);
-    delete it->second, it->second = NULL;
+    delete it->second, it->second = nullptr;
   }
   pending_connects_.clear();
   for (StalledRequestQueue::iterator it = stalled_request_queue_.begin();
        it != stalled_request_queue_.end();
        ++it) {
     InvokeUserCallbackLater(it->handle, it->callback, error);
   }
   stalled_request_map_.clear();
   stalled_request_queue_.clear();
   flushing_ = false;
@@ skipping 100 matching lines @@
 
   bool handed_out_socket = TryHandOutSocket(result, job);
 
   CompletionCallback callback = job->callback();
 
   ClientSocketHandle* const handle = job->handle();
 
   bool delete_succeeded = DeleteJob(handle);
   DCHECK(delete_succeeded);
 
-  job = NULL;
+  job = nullptr;
 
   if (!handed_out_socket)
     ActivateStalledRequest();
 
   InvokeUserCallbackLater(handle, callback, result);
 }
 
 void WebSocketTransportClientSocketPool::InvokeUserCallbackLater(
     ClientSocketHandle* handle,
     const CompletionCallback& callback,
@@ skipping 51 matching lines @@
 
 bool WebSocketTransportClientSocketPool::DeleteJob(ClientSocketHandle* handle) {
   PendingConnectsMap::iterator it = pending_connects_.find(handle);
   if (it == pending_connects_.end())
     return false;
   // Deleting a ConnectJob which holds an endpoint lock can lead to a different
   // ConnectJob proceeding to connect. If the connect proceeds synchronously
   // (usually because of a failure) then it can trigger that job to be
   // deleted. |it| remains valid because std::map guarantees that erase() does
   // not invalid iterators to other entries.
-  delete it->second, it->second = NULL;
+  delete it->second, it->second = nullptr;
   DCHECK(pending_connects_.find(handle) == it);
   pending_connects_.erase(it);
   return true;
 }
 
 const WebSocketTransportConnectJob*
 WebSocketTransportClientSocketPool::LookupConnectJob(
     const ClientSocketHandle* handle) const {
   PendingConnectsMap::const_iterator it = pending_connects_.find(handle);
   CHECK(it != pending_connects_.end());
@@ skipping 57 matching lines @@
       handle(handle),
       callback(callback),
       net_log(net_log) {}
 
 WebSocketTransportClientSocketPool::StalledRequest::StalledRequest(
     const StalledRequest& other) = default;
 
 WebSocketTransportClientSocketPool::StalledRequest::~StalledRequest() {}
 
 }  // namespace net