Submission for C++ Readability

device/bluetooth/bluetooth_socket_chromeos.cc

 // Copyright 2013 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 "device/bluetooth/bluetooth_socket_chromeos.h"
 
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 67 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<BluetoothSocketThread> socket_thread)
     : BluetoothSocketNet(ui_task_runner, socket_thread), profile_(nullptr) {
 }
 
 BluetoothSocketChromeOS::~BluetoothSocketChromeOS() {
   DCHECK(!profile_);
 
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
-    adapter_ = NULL;
+    adapter_ = nullptr;
   }
 }
 
 void BluetoothSocketChromeOS::Connect(
     const BluetoothDeviceChromeOS* device,
     const BluetoothUUID& uuid,
     SecurityLevel security_level,
     const base::Closure& success_callback,
     const ErrorCompletionCallback& error_callback) {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
@@ skipping 61 matching lines @@
 
   if (profile_)
     UnregisterProfile();
 
   // In the case below, where an asynchronous task gets posted on the socket
   // thread in BluetoothSocketNet::Close, a reference will be held to this
   // socket by the callback. This may cause the BluetoothAdapter to outlive
   // DBusThreadManager during shutdown if that callback executes too late.
   if (adapter_.get()) {
     adapter_->RemoveObserver(this);
-    adapter_ = NULL;
+    adapter_ = nullptr;
   }
 
   if (!device_path_.value().empty()) {
     BluetoothSocketNet::Close();
   } else {
     DoCloseListening();
   }
 }
 
 void BluetoothSocketChromeOS::Disconnect(const base::Closure& callback) {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 
   if (profile_)
-   UnregisterProfile();
+    UnregisterProfile();
 
   if (!device_path_.value().empty()) {
     BluetoothSocketNet::Disconnect(callback);
   } else {
     DoCloseListening();
     callback.Run();
   }
 }
 
 void BluetoothSocketChromeOS::Accept(
@@ skipping 320 matching lines @@
     BluetoothDeviceChromeOS* device =
         static_cast<BluetoothAdapterChromeOS*>(adapter_.get())->
             GetDeviceWithPath(request->device_path);
     DCHECK(device);
 
     accept_request_->success_callback.Run(device, socket);
   } else {
     accept_request_->error_callback.Run(kAcceptFailed);
   }
 
-  accept_request_.reset(NULL);
+  accept_request_.reset(nullptr);
   connection_request_queue_.pop();
 
   callback.Run(status);
 }
 
 void BluetoothSocketChromeOS::DoCloseListening() {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 
   if (accept_request_) {
     accept_request_->error_callback.Run(
         net::ErrorToString(net::ERR_CONNECTION_CLOSED));
-    accept_request_.reset(NULL);
+    accept_request_.reset(nullptr);
   }
 
   while (connection_request_queue_.size() > 0) {
     linked_ptr<ConnectionRequest> request = connection_request_queue_.front();
     request->callback.Run(REJECTED);
     connection_request_queue_.pop();
   }
 }
 
 void BluetoothSocketChromeOS::UnregisterProfile() {
   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
   DCHECK(profile_);
 
   VLOG(1) << profile_->object_path().value() << ": Release profile";
 
   static_cast<BluetoothAdapterChromeOS*>(adapter_.get())
       ->ReleaseProfile(device_path_, profile_);
   profile_ = nullptr;
 }
 
 }  // namespace chromeos
+