Run clang-modernize -use-nullptr over src/extensions/.

extensions/browser/api/socket/tcp_socket.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 "extensions/browser/api/socket/tcp_socket.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "extensions/browser/api/api_resource.h"
@@ skipping 84 matching lines @@
     if (is_connected_)
       break;
 
     net::AddressList address_list;
     if (!StringAndPortToAddressList(address, port, &address_list)) {
       result = net::ERR_ADDRESS_INVALID;
       break;
     }
 
     socket_.reset(
-        new net::TCPClientSocket(address_list, NULL, net::NetLog::Source()));
+        new net::TCPClientSocket(address_list, nullptr, net::NetLog::Source()));
 
     connect_callback_ = callback;
     result = socket_->Connect(
         base::Bind(&TCPSocket::OnConnectComplete, base::Unretained(this)));
   } while (false);
 
   if (result != net::ERR_IO_PENDING)
     OnConnectComplete(result);
 }
 
 void TCPSocket::Disconnect() {
   is_connected_ = false;
   if (socket_.get())
     socket_->Disconnect();
-  server_socket_.reset(NULL);
+  server_socket_.reset(nullptr);
   connect_callback_.Reset();
   read_callback_.Reset();
   accept_callback_.Reset();
-  accept_socket_.reset(NULL);
+  accept_socket_.reset(nullptr);
 }
 
 int TCPSocket::Bind(const std::string& address, int port) {
   return net::ERR_FAILED;
 }
 
 void TCPSocket::Read(int count, const ReadCompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   if (socket_mode_ != CLIENT) {
-    callback.Run(net::ERR_FAILED, NULL);
+    callback.Run(net::ERR_FAILED, nullptr);
     return;
   }
 
   if (!read_callback_.is_null()) {
-    callback.Run(net::ERR_IO_PENDING, NULL);
+    callback.Run(net::ERR_IO_PENDING, nullptr);
     return;
   }
 
   if (count < 0) {
-    callback.Run(net::ERR_INVALID_ARGUMENT, NULL);
+    callback.Run(net::ERR_INVALID_ARGUMENT, nullptr);
     return;
   }
 
   if (!socket_.get() || !IsConnected()) {
-    callback.Run(net::ERR_SOCKET_NOT_CONNECTED, NULL);
+    callback.Run(net::ERR_SOCKET_NOT_CONNECTED, nullptr);
     return;
   }
 
   read_callback_ = callback;
   scoped_refptr<net::IOBuffer> io_buffer = new net::IOBuffer(count);
   int result = socket_->Read(
       io_buffer.get(),
       count,
       base::Bind(
           &TCPSocket::OnReadComplete, base::Unretained(this), io_buffer));
 
   if (result != net::ERR_IO_PENDING)
     OnReadComplete(io_buffer, result);
 }
 
 void TCPSocket::RecvFrom(int count,
                          const RecvFromCompletionCallback& callback) {
-  callback.Run(net::ERR_FAILED, NULL, NULL, 0);
+  callback.Run(net::ERR_FAILED, nullptr, nullptr, 0);
 }
 
 void TCPSocket::SendTo(scoped_refptr<net::IOBuffer> io_buffer,
                        int byte_count,
                        const std::string& address,
                        int port,
                        const CompletionCallback& callback) {
   callback.Run(net::ERR_FAILED);
 }
 
@@ skipping 14 matching lines @@
                       int backlog,
                       std::string* error_msg) {
   if (socket_mode_ == CLIENT) {
     *error_msg = kTCPSocketTypeInvalidError;
     return net::ERR_NOT_IMPLEMENTED;
   }
   DCHECK(!socket_.get());
   socket_mode_ = SERVER;
 
   if (!server_socket_.get()) {
-    server_socket_.reset(new net::TCPServerSocket(NULL, net::NetLog::Source()));
+    server_socket_.reset(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
   }
 
   int result = server_socket_->ListenWithAddressAndPort(address, port, backlog);
   if (result)
     *error_msg = kSocketListenError;
   return result;
 }
 
 void TCPSocket::Accept(const AcceptCompletionCallback& callback) {
   if (socket_mode_ != SERVER || !server_socket_.get()) {
-    callback.Run(net::ERR_FAILED, NULL);
+    callback.Run(net::ERR_FAILED, nullptr);
     return;
   }
 
   // Limits to only 1 blocked accept call.
   if (!accept_callback_.is_null()) {
-    callback.Run(net::ERR_FAILED, NULL);
+    callback.Run(net::ERR_FAILED, nullptr);
     return;
   }
 
   int result = server_socket_->Accept(
       &accept_socket_,
       base::Bind(&TCPSocket::OnAccept, base::Unretained(this)));
   if (result == net::ERR_IO_PENDING) {
     accept_callback_ = callback;
   } else if (result == net::OK) {
     accept_callback_ = callback;
     this->OnAccept(result);
   } else {
-    callback.Run(result, NULL);
+    callback.Run(result, nullptr);
   }
 }
 
 bool TCPSocket::IsConnected() {
   RefreshConnectionStatus();
   return is_connected_;
 }
 
 bool TCPSocket::GetPeerAddress(net::IPEndPoint* address) {
   if (!socket_.get())
@@ skipping 48 matching lines @@
   read_callback_.Run(result, io_buffer);
   read_callback_.Reset();
 }
 
 void TCPSocket::OnAccept(int result) {
   DCHECK(!accept_callback_.is_null());
   if (result == net::OK && accept_socket_.get()) {
     accept_callback_.Run(
         result, static_cast<net::TCPClientSocket*>(accept_socket_.release()));
   } else {
-    accept_callback_.Run(result, NULL);
+    accept_callback_.Run(result, nullptr);
   }
   accept_callback_.Reset();
 }
 
 void TCPSocket::Release() {
   // Release() is only invoked when the underlying sockets are taken (via
   // ClientStream()) by TLSSocket. TLSSocket only supports CLIENT-mode
   // sockets.
   DCHECK(!server_socket_.release() && !accept_socket_.release() &&
          socket_mode_ == CLIENT)
       << "Called in server mode.";
 
   // Release() doesn't disconnect the underlying sockets, but it does
   // disconnect them from this TCPSocket.
   is_connected_ = false;
 
   connect_callback_.Reset();
   read_callback_.Reset();
   accept_callback_.Reset();
 
   DCHECK(socket_.get()) << "Called on null client socket.";
   ignore_result(socket_.release());
 }
 
 net::TCPClientSocket* TCPSocket::ClientStream() {
   if (socket_mode_ != CLIENT || GetSocketType() != TYPE_TCP)
-    return NULL;
+    return nullptr;
   return socket_.get();
 }
 
 bool TCPSocket::HasPendingRead() const {
   return !read_callback_.is_null();
 }
 
 ResumableTCPSocket::ResumableTCPSocket(const std::string& owner_extension_id)
     : TCPSocket(owner_extension_id),
       persistent_(false),
@@ skipping 10 matching lines @@
 
 bool ResumableTCPSocket::IsPersistent() const { return persistent(); }
 
 ResumableTCPServerSocket::ResumableTCPServerSocket(
     const std::string& owner_extension_id)
     : TCPSocket(owner_extension_id), persistent_(false), paused_(false) {}
 
 bool ResumableTCPServerSocket::IsPersistent() const { return persistent(); }
 
 }  // namespace extensions