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

extensions/browser/api/socket/socket_api.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/socket_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 72 matching lines @@
 
 base::hash_set<int>* SocketAsyncApiFunction::GetSocketIds() {
   return manager_->GetResourceIds(extension_->id());
 }
 
 void SocketAsyncApiFunction::RemoveSocket(int api_resource_id) {
   manager_->Remove(extension_->id(), api_resource_id);
 }
 
 SocketExtensionWithDnsLookupFunction::SocketExtensionWithDnsLookupFunction()
-    : resource_context_(NULL),
+    : resource_context_(nullptr),
       request_handle_(new net::HostResolver::RequestHandle),
-      addresses_(new net::AddressList) {}
+      addresses_(new net::AddressList) {
+}
 
 SocketExtensionWithDnsLookupFunction::~SocketExtensionWithDnsLookupFunction() {}
 
 bool SocketExtensionWithDnsLookupFunction::PrePrepare() {
   if (!SocketAsyncApiFunction::PrePrepare())
     return false;
   resource_context_ = browser_context()->GetResourceContext();
-  return resource_context_ != NULL;
+  return resource_context_ != nullptr;
 }
 
 void SocketExtensionWithDnsLookupFunction::StartDnsLookup(
     const std::string& hostname) {
   net::HostResolver* host_resolver =
       HostResolverWrapper::GetInstance()->GetHostResolver(resource_context_);
   DCHECK(host_resolver);
 
   // Yes, we are passing zero as the port. There are some interesting but not
   // presently relevant reasons why HostResolver asks for the port of the
@@ skipping 42 matching lines @@
       break;
     case extensions::core_api::socket::SOCKET_TYPE_NONE:
       NOTREACHED();
       break;
   }
 
   return true;
 }
 
 void SocketCreateFunction::Work() {
-  Socket* socket = NULL;
+  Socket* socket = nullptr;
   if (socket_type_ == kSocketTypeTCP) {
     socket = new TCPSocket(extension_->id());
   } else if (socket_type_ == kSocketTypeUDP) {
     socket = new UDPSocket(extension_->id());
   }
   DCHECK(socket);
 
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kSocketIdKey, AddSocket(socket));
   SetResult(result);
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDestroyFunction::Work() { RemoveSocket(socket_id_); }
 
 SocketConnectFunction::SocketConnectFunction()
-    : socket_id_(0), hostname_(), port_(0), socket_(NULL) {}
+    : socket_id_(0), hostname_(), port_(0), socket_(nullptr) {
+}
 
 SocketConnectFunction::~SocketConnectFunction() {}
 
 bool SocketConnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
@@ skipping 149 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketAcceptFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     socket->Accept(base::Bind(&SocketAcceptFunction::OnAccept, this));
   } else {
     error_ = kSocketNotFoundError;
-    OnAccept(-1, NULL);
+    OnAccept(-1, nullptr);
   }
 }
 
 void SocketAcceptFunction::OnAccept(int result_code,
                                     net::TCPClientSocket* socket) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, result_code);
   if (socket) {
     Socket* client_socket = new TCPSocket(socket, extension_id(), true);
     result->SetInteger(kSocketIdKey, AddSocket(client_socket));
@@ skipping 10 matching lines @@
 bool SocketReadFunction::Prepare() {
   params_ = core_api::socket::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketReadFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    OnCompleted(-1, NULL);
+    OnCompleted(-1, nullptr);
     return;
   }
 
   socket->Read(params_->buffer_size.get() ? *params_->buffer_size.get() : 4096,
                base::Bind(&SocketReadFunction::OnCompleted, this));
 }
 
 void SocketReadFunction::OnCompleted(int bytes_read,
                                      scoped_refptr<net::IOBuffer> io_buffer) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     result->Set(kDataKey, new base::BinaryValue());
   }
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketWriteFunction::SocketWriteFunction()
-    : socket_id_(0), io_buffer_(NULL), io_buffer_size_(0) {}
+    : socket_id_(0), io_buffer_(nullptr), io_buffer_size_(0) {
+}
 
 SocketWriteFunction::~SocketWriteFunction() {}
 
 bool SocketWriteFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  base::BinaryValue* data = NULL;
+  base::BinaryValue* data = nullptr;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketWriteFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
 
@@ skipping 23 matching lines @@
 bool SocketRecvFromFunction::Prepare() {
   params_ = core_api::socket::RecvFrom::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketRecvFromFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    OnCompleted(-1, NULL, std::string(), 0);
+    OnCompleted(-1, nullptr, std::string(), 0);
     return;
   }
 
   socket->RecvFrom(params_->buffer_size.get() ? *params_->buffer_size : 4096,
                    base::Bind(&SocketRecvFromFunction::OnCompleted, this));
 }
 
 void SocketRecvFromFunction::OnCompleted(int bytes_read,
                                          scoped_refptr<net::IOBuffer> io_buffer,
                                          const std::string& address,
                                          int port) {
   base::DictionaryValue* result = new base::DictionaryValue();
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     result->Set(kDataKey, new base::BinaryValue());
   }
   result->SetString(kAddressKey, address);
   result->SetInteger(kPortKey, port);
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketSendToFunction::SocketSendToFunction()
     : socket_id_(0),
-      io_buffer_(NULL),
+      io_buffer_(nullptr),
       io_buffer_size_(0),
       port_(0),
-      socket_(NULL) {}
+      socket_(nullptr) {
+}
 
 SocketSendToFunction::~SocketSendToFunction() {}
 
 bool SocketSendToFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
-  base::BinaryValue* data = NULL;
+  base::BinaryValue* data = nullptr;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port_));
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
@@ skipping 408 matching lines @@
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
     error_ = kSocketNotFoundError;
     AsyncWorkCompleted();
     return;
   }
 
   // Make sure that the socket is a TCP client socket.
   if (socket->GetSocketType() != Socket::TYPE_TCP ||
-      static_cast<TCPSocket*>(socket)->ClientStream() == NULL) {
+      static_cast<TCPSocket*>(socket)->ClientStream() == nullptr) {
     SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
     error_ = kSecureSocketTypeError;
     AsyncWorkCompleted();
     return;
   }
 
   if (!socket->IsConnected()) {
     SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
     error_ = kSocketNotConnectedError;
     AsyncWorkCompleted();
     return;
   }
 
   net::URLRequestContext* url_request_context =
       url_request_getter_->GetURLRequestContext();
 
   TLSSocket::UpgradeSocketToTLS(
       socket,
       url_request_context->ssl_config_service(),
       url_request_context->cert_verifier(),
       url_request_context->transport_security_state(),
       extension_id(),
       params_->options.get(),
       base::Bind(&SocketSecureFunction::TlsConnectDone, this));
 }
 
 void SocketSecureFunction::TlsConnectDone(scoped_ptr<TLSSocket> socket,
                                           int result) {
   // if an error occurred, socket MUST be NULL.
-  DCHECK(result == net::OK || socket == NULL);
+  DCHECK(result == net::OK || socket == nullptr);
 
   if (socket && result == net::OK) {
     ReplaceSocket(params_->socket_id, socket.release());
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = core_api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions