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

extensions/browser/api/sockets_udp/sockets_udp_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_udp/sockets_udp_api.h"
 
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/udp_socket.h"
 #include "extensions/browser/api/sockets_udp/udp_socket_event_dispatcher.h"
 #include "extensions/common/api/sockets/sockets_manifest_data.h"
@@ skipping 114 matching lines @@
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   SetSocketProperties(socket, &params_.get()->properties);
   results_ = sockets_udp::Update::Results::Create();
 }
 
 SocketsUdpSetPausedFunction::SocketsUdpSetPausedFunction()
-    : socket_event_dispatcher_(NULL) {}
+    : socket_event_dispatcher_(nullptr) {
+}
 
 SocketsUdpSetPausedFunction::~SocketsUdpSetPausedFunction() {}
 
 bool SocketsUdpSetPausedFunction::Prepare() {
   params_ = core_api::sockets_udp::SetPaused::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = UDPSocketEventDispatcher::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 "
          "UDPSocketEventDispatcher.";
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void SocketsUdpSetPausedFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   if (socket->paused() != params_->paused) {
     socket->set_paused(params_->paused);
     if (socket->IsBound() && !params_->paused) {
       socket_event_dispatcher_->OnSocketResume(extension_->id(),
                                                params_->socket_id);
     }
   }
 
   results_ = sockets_udp::SetPaused::Results::Create();
 }
 
 SocketsUdpBindFunction::SocketsUdpBindFunction()
-    : socket_event_dispatcher_(NULL) {}
+    : socket_event_dispatcher_(nullptr) {
+}
 
 SocketsUdpBindFunction::~SocketsUdpBindFunction() {}
 
 bool SocketsUdpBindFunction::Prepare() {
   params_ = sockets_udp::Bind::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = UDPSocketEventDispatcher::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 "
          "UDPSocketEventDispatcher.";
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void SocketsUdpBindFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   content::SocketPermissionRequest param(
@@ skipping 138 matching lines @@
 
 SocketsUdpGetSocketsFunction::SocketsUdpGetSocketsFunction() {}
 
 SocketsUdpGetSocketsFunction::~SocketsUdpGetSocketsFunction() {}
 
 bool SocketsUdpGetSocketsFunction::Prepare() { return true; }
 
 void SocketsUdpGetSocketsFunction::Work() {
   std::vector<linked_ptr<sockets_udp::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;
       ResumableUDPSocket* socket = GetUdpSocket(socket_id);
       if (socket) {
         socket_infos.push_back(CreateSocketInfo(socket_id, socket));
       }
     }
   }
@@ skipping 141 matching lines @@
     error_ = kPermissionError;
     return;
   }
 
   const std::vector<std::string>& groups = socket->GetJoinedGroups();
   results_ = sockets_udp::GetJoinedGroups::Results::Create(groups);
 }
 
 }  // namespace core_api
 }  // namespace extensions