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

extensions/browser/api/sockets_tcp/sockets_tcp_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/sockets_tcp/sockets_tcp_api.h"
 
 #include "content/public/browser/browser_context.h"
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
 #include "extensions/browser/api/socket/tls_socket.h"
@@ skipping 139 matching lines @@
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   SetSocketProperties(socket, &params_.get()->properties);
   results_ = sockets_tcp::Update::Results::Create();
 }
 
 SocketsTcpSetPausedFunction::SocketsTcpSetPausedFunction()
-    : socket_event_dispatcher_(NULL) {}
+    : socket_event_dispatcher_(nullptr) {
+}
 
 SocketsTcpSetPausedFunction::~SocketsTcpSetPausedFunction() {}
 
 bool SocketsTcpSetPausedFunction::Prepare() {
   params_ = core_api::sockets_tcp::SetPaused::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = TCPSocketEventDispatcher::Get(browser_context());
   DCHECK(socket_event_dispatcher_)
       << "There is no socket event dispatcher. "
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "TCPSocketEventDispatcher.";
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void SocketsTcpSetPausedFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   if (socket->paused() != params_->paused) {
@@ skipping 51 matching lines @@
   }
 
   bool success = socket->SetNoDelay(params_->no_delay);
   int net_result = (success ? net::OK : net::ERR_FAILED);
   if (net_result != net::OK)
     error_ = net::ErrorToString(net_result);
   results_ = sockets_tcp::SetNoDelay::Results::Create(net_result);
 }
 
 SocketsTcpConnectFunction::SocketsTcpConnectFunction()
-    : socket_event_dispatcher_(NULL) {}
+    : socket_event_dispatcher_(nullptr) {
+}
 
 SocketsTcpConnectFunction::~SocketsTcpConnectFunction() {}
 
 bool SocketsTcpConnectFunction::Prepare() {
   params_ = sockets_tcp::Connect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = TCPSocketEventDispatcher::Get(browser_context());
   DCHECK(socket_event_dispatcher_)
       << "There is no socket event dispatcher. "
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "TCPSocketEventDispatcher.";
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void SocketsTcpConnectFunction::AsyncWorkStart() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     AsyncWorkCompleted();
     return;
   }
 
@@ skipping 158 matching lines @@
 
 SocketsTcpGetSocketsFunction::SocketsTcpGetSocketsFunction() {}
 
 SocketsTcpGetSocketsFunction::~SocketsTcpGetSocketsFunction() {}
 
 bool SocketsTcpGetSocketsFunction::Prepare() { return true; }
 
 void SocketsTcpGetSocketsFunction::Work() {
   std::vector<linked_ptr<sockets_tcp::SocketInfo> > socket_infos;
   base::hash_set<int>* resource_ids = GetSocketIds();
-  if (resource_ids != NULL) {
+  if (resource_ids != nullptr) {
     for (base::hash_set<int>::iterator it = resource_ids->begin();
          it != resource_ids->end();
          ++it) {
       int socket_id = *it;
       ResumableTCPSocket* socket = GetTcpSocket(socket_id);
       if (socket) {
         socket_infos.push_back(CreateSocketInfo(socket_id, socket));
       }
     }
   }
@@ skipping 26 matching lines @@
     AsyncWorkCompleted();
     return;
   }
 
   paused_ = socket->paused();
   persistent_ = socket->persistent();
 
   // Make sure it's a connected TCP client socket. Error out if it's already
   // secure()'d.
   if (socket->GetSocketType() != Socket::TYPE_TCP ||
-      socket->ClientStream() == NULL) {
+      socket->ClientStream() == nullptr) {
     SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
     error_ = kInvalidSocketStateError;
     AsyncWorkCompleted();
     return;
   }
 
   if (!socket->IsConnected()) {
     SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
     error_ = kSocketNotConnectedError;
     AsyncWorkCompleted();
@@ skipping 25 matching lines @@
       url_request_context->cert_verifier(),
       url_request_context->transport_security_state(),
       extension_id(),
       &legacy_params,
       base::Bind(&SocketsTcpSecureFunction::TlsConnectDone, this));
 }
 
 void SocketsTcpSecureFunction::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) {
     socket->set_persistent(persistent_);
     socket->set_paused(paused_);
     ReplaceSocket(params_->socket_id, socket.release());
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = core_api::sockets_tcp::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace api
 }  // namespace extensions