bluetooth: Add Device connection logic and accompanying user interface.

device/bluetooth/device.cc

Index: device/bluetooth/device.cc
diff --git a/device/bluetooth/device.cc b/device/bluetooth/device.cc
index 7e662802eabb5aed91c9859f782903049c866170..2094107538a48558234db191f8b076d5b2d18d33 100644
--- a/device/bluetooth/device.cc
+++ b/device/bluetooth/device.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include <utility>
+#include <vector>
 
 #include "base/strings/utf_string_conversions.h"
 #include "device/bluetooth/device.h"
@@ -10,11 +11,23 @@
 
 namespace bluetooth {
 
-Device::Device(const std::string& address,
-               scoped_refptr<device::BluetoothAdapter> adapter)
-    : address_(address), adapter_(std::move(adapter)) {}
+Device::Device(scoped_refptr<device::BluetoothAdapter> adapter,
+               std::unique_ptr<device::BluetoothGattConnection> connection,
+               mojom::DeviceRequest request)
+    : adapter_(std::move(adapter)),
+      connection_(std::move(connection)),
+      binding_(this, std::move(request)) {
+  // Binding is owned by this Device, so base::Unretatined is safe.

[dcheng, 2016/11/11 01:25:33]

Nit: typo

[mbrunson, 2016/11/11 21:26:15]

Done.

+  binding_.set_connection_error_handler(
+      base::Bind(&Device::Disconnect, base::Unretained(this)));

[dcheng, 2016/11/11 01:25:33]

Let's just use StrongBinding. It does make this code a bit more complicated
(specifically, the delete this in DeviceChanged), but it requires less "delete
this"... so I think that's a net win overall.

[mbrunson, 2016/11/11 21:26:15]

So, would you recommend moving control of the binding to the Adapter since the
Device can't control its own lifetime?

[dcheng, 2016/11/15 07:24:02]

Yes, this implies Adapter will be calling MakeStrongBinding.

[mbrunson, 2016/11/15 21:50:35]

I hesitate to do this. 

As you said, this complicates the code quite a bit and will require many more
tests to verify the proper management of all of the active Device instances.
I've seen the current approach used in places with similar lifetime concerns [1]
where the interface's lifetime is managed by both the message pipe and some
other object.

[1]
https://cs.chromium.org/chromium/src/device/usb/mojo/device_manager_impl.cc?r...

[ortuno, 2016/11/15 21:58:09]

+1

[mbrunson, 2016/11/16 03:32:03]

Done.

 
-Device::~Device() {}
+  adapter_->AddObserver(this);
+}
+
+Device::~Device() {
+  binding_.Close();
+  adapter_->RemoveObserver(this);
+}
 
 // static
 mojom::DeviceInfoPtr Device::ConstructDeviceInfoStruct(
@@ -25,6 +38,7 @@ mojom::DeviceInfoPtr Device::ConstructDeviceInfoStruct(
   device_info->name_for_display =
       base::UTF16ToUTF8(device->GetNameForDisplay());
   device_info->address = device->GetAddress();
+  device_info->is_gatt_connected = device->IsGattConnected();
 
   if (device->GetInquiryRSSI()) {
     device_info->rssi = mojom::RSSIWrapper::New();
@@ -34,14 +48,88 @@ mojom::DeviceInfoPtr Device::ConstructDeviceInfoStruct(
   return device_info;
 }
 
+mojo::Binding<mojom::Device>* Device::GetBindingForTesting() {
+  return &binding_;
+}
+
+void Device::DeviceChanged(device::BluetoothAdapter* adapter,
+                           device::BluetoothDevice* device) {
+  if (device->GetAddress() != GetAddress()) {
+    return;
+  }
+
+  if (!device->IsGattConnected()) {
+    delete this;
+  }
+}
+
+void Device::GattServicesDiscovered(device::BluetoothAdapter* adapter,
+                                    device::BluetoothDevice* device) {
+  if (device->GetAddress() != GetAddress()) {
+    return;
+  }
+
+  std::vector<base::Closure> requests;
+  requests.swap(pending_services_requests_);
+  for (const base::Closure& request : requests) {
+    request.Run();
+  }
+}
+
+void Device::Disconnect() {
+  delete this;
+}
+
 void Device::GetInfo(const GetInfoCallback& callback) {
-  device::BluetoothDevice* device = adapter_->GetDevice(address_);
-  if (device) {
-    mojom::DeviceInfoPtr device_info = ConstructDeviceInfoStruct(device);
-    callback.Run(std::move(device_info));
-  } else {
-    callback.Run(nullptr);
+  device::BluetoothDevice* device = adapter_->GetDevice(GetAddress());
+  DCHECK(device);
+
+  mojom::DeviceInfoPtr device_info = ConstructDeviceInfoStruct(device);
+  callback.Run(std::move(device_info));
+}
+
+void Device::GetServices(const GetServicesCallback& callback) {
+  device::BluetoothDevice* device = adapter_->GetDevice(GetAddress());
+  DCHECK(device);
+
+  if (device->IsGattServicesDiscoveryComplete()) {
+    GetServicesImpl(callback);
+    return;
   }
+
+  // pending_services_requests_ is owned by Device, so base::Unretatined is
+  // safe.
+  pending_services_requests_.push_back(
+      base::Bind(&Device::GetServicesImpl, base::Unretained(this), callback));
+}
+
+void Device::GetServicesImpl(const GetServicesCallback& callback) {
+  device::BluetoothDevice* device = adapter_->GetDevice(GetAddress());
+  DCHECK(device);
+
+  std::vector<mojom::ServiceInfoPtr> services;
+
+  for (const device::BluetoothRemoteGattService* service :
+       device->GetGattServices()) {
+    mojom::ServiceInfoPtr service_info = ConstructServiceInfoStruct(*service);
+    services.push_back(std::move(service_info));
+  }
+
+  callback.Run(std::move(services));
+}
+
+mojom::ServiceInfoPtr Device::ConstructServiceInfoStruct(
+    const device::BluetoothRemoteGattService& service) {
+  mojom::ServiceInfoPtr service_info = mojom::ServiceInfo::New();
+
+  service_info->uuid = service.GetUUID();
+  service_info->is_primary = service.IsPrimary();
+
+  return service_info;
+}
+
+const std::string& Device::GetAddress() {
+  return connection_->GetDeviceAddress();
 }
 
 }  // namespace bluetooth