bluetooth: Standardize Bluetooth adapter access in Adapter service.

device/bluetooth/adapter.cc

 // Copyright 2016 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 <string>
 #include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 12 matching lines @@
     adapter_ = nullptr;
   }
 }
 
 // static
 void Adapter::Create(mojom::AdapterRequest request) {
   mojo::MakeStrongBinding(base::MakeUnique<Adapter>(), std::move(request));
 }
 
 void Adapter::GetDevices(const GetDevicesCallback& callback) {
-  if (!adapter_) {
-    if (device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
-      base::Closure c = base::Bind(&Adapter::GetDevicesImpl,
-                                   weak_ptr_factory_.GetWeakPtr(), callback);
+  WithAdapter(base::Bind(
+      [](const GetDevicesCallback& callback,
+         scoped_refptr<device::BluetoothAdapter> adapter) {
+        if (adapter) {
+          std::vector<mojom::DeviceInfoPtr> devices;
+          for (const device::BluetoothDevice* device : adapter->GetDevices()) {
+            mojom::DeviceInfoPtr device_info =
+                ConstructDeviceInfoStruct(device);
+            devices.push_back(std::move(device_info));
+          }
 
-      device::BluetoothAdapterFactory::GetAdapter(base::Bind(
-          &Adapter::OnGetAdapter, weak_ptr_factory_.GetWeakPtr(), c));
-      return;
-    }
-    callback.Run(std::vector<mojom::DeviceInfoPtr>());
-    return;
-  }
-  GetDevicesImpl(callback);
+          callback.Run(std::move(devices));
+        } else {
+          callback.Run(std::vector<mojom::DeviceInfoPtr>());
+        }
+      },
+      callback));
 }
 
 void Adapter::SetClient(mojom::AdapterClientPtr client) {
   client_ = std::move(client);
 }
 
 void Adapter::DeviceAdded(device::BluetoothAdapter* adapter,
                           device::BluetoothDevice* device) {
   if (client_) {
     auto device_info = ConstructDeviceInfoStruct(device);
     client_->DeviceAdded(std::move(device_info));
   }
 }
 
 void Adapter::DeviceRemoved(device::BluetoothAdapter* adapter,
                             device::BluetoothDevice* device) {
   if (client_) {
     auto device_info = ConstructDeviceInfoStruct(device);
     client_->DeviceRemoved(std::move(device_info));
   }
 }
 
+// static
 mojom::DeviceInfoPtr Adapter::ConstructDeviceInfoStruct(
-    const device::BluetoothDevice* device) const {
+    const device::BluetoothDevice* const device) {
   mojom::DeviceInfoPtr device_info = mojom::DeviceInfo::New();
 
   device_info->name = device->GetName();
   device_info->name_for_display =
       base::UTF16ToUTF8(device->GetNameForDisplay());
   device_info->id = device->GetIdentifier();
   device_info->address = device->GetAddress();
 
   return device_info;
 }
 
-void Adapter::GetDevicesImpl(const GetDevicesCallback& callback) {
-  std::vector<mojom::DeviceInfoPtr> devices;
-
-  for (const device::BluetoothDevice* device : adapter_->GetDevices()) {
-    mojom::DeviceInfoPtr device_info = ConstructDeviceInfoStruct(device);
-    devices.push_back(std::move(device_info));
+void Adapter::WithAdapter(
+    const device::BluetoothAdapterFactory::AdapterCallback& action) {
+  if (adapter_) {
+    action.Run(adapter_);

[scheib, 2016/09/30 21:52:01]

add return here, or remove the return below and chain the three blocks with
"else if".

[mbrunson, 2016/09/30 22:13:02]

Done.

   }
 
-  callback.Run(std::move(devices));
+  if (device::BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
+    device::BluetoothAdapterFactory::GetAdapter(base::Bind(
+        &Adapter::OnGetAdapter, weak_ptr_factory_.GetWeakPtr(), action));
+    return;
+  }
+
+  action.Run(nullptr);
 }
 
-void Adapter::OnGetAdapter(const base::Closure& continuation,
-                           scoped_refptr<device::BluetoothAdapter> adapter) {
+void Adapter::OnGetAdapter(
+    const device::BluetoothAdapterFactory::AdapterCallback& continuation,
+    scoped_refptr<device::BluetoothAdapter> adapter) {
   if (!adapter_) {
     VLOG(1) << "Adapter acquired";
     adapter_ = adapter;
     adapter_->AddObserver(this);
   }
-  continuation.Run();
+  continuation.Run(adapter);
 }
 
 }  // namespace bluetooth