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

extensions/browser/api/bluetooth_socket/bluetooth_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/bluetooth_socket/bluetooth_socket_api.h"
 
 #include <stdint.h>
 
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 122 matching lines @@
     error_ = kPermissionDeniedError;
     return false;
   }
 
   manager_ = ApiResourceManager<BluetoothApiSocket>::Get(browser_context());
   DCHECK(manager_)
       << "There is no socket manager. "
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "ApiResourceManager<BluetoothApiSocket>.";
-  return manager_ != NULL;
+  return manager_ != nullptr;
 }
 
 bool BluetoothSocketAsyncApiFunction::Respond() { return error_.empty(); }
 
 void BluetoothSocketAsyncApiFunction::AsyncWorkCompleted() {
   SendResponse(Respond());
 }
 
 void BluetoothSocketAsyncApiFunction::Work() {}
 
@@ skipping 68 matching lines @@
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   SetSocketProperties(socket, &params_.get()->properties);
   results_ = bluetooth_socket::Update::Results::Create();
 }
 
 BluetoothSocketSetPausedFunction::BluetoothSocketSetPausedFunction()
-    : socket_event_dispatcher_(NULL) {}
+    : socket_event_dispatcher_(nullptr) {
+}
 
 BluetoothSocketSetPausedFunction::~BluetoothSocketSetPausedFunction() {}
 
 bool BluetoothSocketSetPausedFunction::Prepare() {
   params_ = bluetooth_socket::SetPaused::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = GetSocketEventDispatcher(browser_context());
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void BluetoothSocketSetPausedFunction::Work() {
   BluetoothApiSocket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   if (socket->paused() != params_->paused) {
     socket->set_paused(params_->paused);
     if (!params_->paused) {
       socket_event_dispatcher_->OnSocketResume(extension_id(),
                                                params_->socket_id);
     }
   }
 
   results_ = bluetooth_socket::SetPaused::Results::Create();
 }
 
 BluetoothSocketListenFunction::BluetoothSocketListenFunction() {}
 
 BluetoothSocketListenFunction::~BluetoothSocketListenFunction() {}
 
 bool BluetoothSocketListenFunction::Prepare() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!CreateParams())
     return false;
   socket_event_dispatcher_ = GetSocketEventDispatcher(browser_context());
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void BluetoothSocketListenFunction::AsyncWorkStart() {
   DCHECK(BrowserThread::CurrentlyOn(work_thread_id()));
   device::BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothSocketListenFunction::OnGetAdapter, this));
 }
 
 void BluetoothSocketListenFunction::OnGetAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
@@ skipping 159 matching lines @@
 
 BluetoothSocketAbstractConnectFunction::
     ~BluetoothSocketAbstractConnectFunction() {}
 
 bool BluetoothSocketAbstractConnectFunction::Prepare() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   params_ = bluetooth_socket::Connect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = GetSocketEventDispatcher(browser_context());
-  return socket_event_dispatcher_ != NULL;
+  return socket_event_dispatcher_ != nullptr;
 }
 
 void BluetoothSocketAbstractConnectFunction::AsyncWorkStart() {
   DCHECK(BrowserThread::CurrentlyOn(work_thread_id()));
   device::BluetoothAdapterFactory::GetAdapter(
       base::Bind(&BluetoothSocketAbstractConnectFunction::OnGetAdapter, this));
 }
 
 void BluetoothSocketAbstractConnectFunction::OnGetAdapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
@@ skipping 191 matching lines @@
 
 BluetoothSocketGetSocketsFunction::BluetoothSocketGetSocketsFunction() {}
 
 BluetoothSocketGetSocketsFunction::~BluetoothSocketGetSocketsFunction() {}
 
 bool BluetoothSocketGetSocketsFunction::Prepare() { return true; }
 
 void BluetoothSocketGetSocketsFunction::Work() {
   std::vector<linked_ptr<bluetooth_socket::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;
       BluetoothApiSocket* socket = GetSocket(socket_id);
       if (socket) {
         socket_infos.push_back(CreateSocketInfo(socket_id, socket));
       }
     }
   }
   results_ = bluetooth_socket::GetSockets::Results::Create(socket_infos);
 }
 
 }  // namespace core_api
 }  // namespace extensions