bluetooth: Add Device connection logic and accompanying user interface.

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 "device/bluetooth/adapter.h"
 #include "device/bluetooth/device.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace bluetooth {
+namespace {
+mojom::ConnectResult BluetoothErrorCodeToMojomResult(
+    device::BluetoothDevice::ConnectErrorCode error_code) {

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

Let's use EnumTraits for this:
https://www.chromium.org/developers/design-documents/mojo/type-mapping

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

Is it possible to use EnumTraits when the C++ class only maps a subset of the
Mojom enum?

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

Yes, that's not a problem.

(If the conversion is only one way, e.g. C++ -> mojom, it'd probably even be OK
to stub out the the deserialization and assert NOTREACHED())

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

I talked to yzshen about this. It's not possible. I would have to add values to
the C++ enum to have full compatibility between the types which doesn't make
sense for the original enum.

[dcheng, 2016/11/17 01:31:47]

Why would it need to do that? We only need to handle the values we expect to be
mapped, and DCHECK() / NOTREACHED() the other things.

[ortuno, 2016/11/17 03:54:44]

I think what mbrunson meant is that the mojo enum is a super set of the C++ enum
i.e. the C++ enum + some other errors.

[mbrunson, 2016/11/17 21:28:01]

Following our chat discussion: Has a simpler alternative for this been found or
should I just leave it as is?

[dcheng, 2016/11/17 21:35:36]

Sorry for the slow responses. I really don't think this sets a good precedent.

Is there a time when we'd want to allow an Adapter to be used without an
AdapterClient? Perhaps we could add methods to AdapterClient for Success/Error
to mirror the C++ interfaces?

[mbrunson, 2016/11/17 23:00:43]

Hmm. It seems really awkward to start an action in one place and then finish it
in another. Extra context will be required on the client side to map to the
right Device interface connection which introduces unnecessary complexity for
all clients.

It seems like it would be simpler to just have a success/error boolean and
typemap the error to get rid of ConnectResult.SUCCESS, but even then the
ConnectResult.DEVICE_NO_LONGER_IN_RANGE value doesn't map to a ConnectErrorCode
value. That means there'd need to be at least two parameters/functions in the
client to typemap properly.

ConnectResult closely resembles the  WebBluetoothResult mojom enum[1] which
implements a switch for this conversion[2].

But I agree. This way is not...ideal.

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/public/platform/modul...

[2]
https://cs.chromium.org/chromium/src/content/browser/bluetooth/web_bluetooth_...

[mbrunson, 2016/11/18 01:53:06]

TypeConverter added. Done.

+  switch (error_code) {
+    case device::BluetoothDevice::ConnectErrorCode::
+        ERROR_ATTRIBUTE_LENGTH_INVALID:
+      return mojom::ConnectResult::ATTRIBUTE_LENGTH_INVALID;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_CANCELED:
+      return mojom::ConnectResult::AUTH_CANCELED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_FAILED:
+      return mojom::ConnectResult::AUTH_FAILED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_REJECTED:
+      return mojom::ConnectResult::AUTH_REJECTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_AUTH_TIMEOUT:
+      return mojom::ConnectResult::AUTH_TIMEOUT;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_CONNECTION_CONGESTED:
+      return mojom::ConnectResult::CONNECTION_CONGESTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_FAILED:
+      return mojom::ConnectResult::FAILED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_INPROGRESS:
+      return mojom::ConnectResult::INPROGRESS;
+    case device::BluetoothDevice::ConnectErrorCode::
+        ERROR_INSUFFICIENT_ENCRYPTION:
+      return mojom::ConnectResult::INSUFFICIENT_ENCRYPTION;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_OFFSET_INVALID:
+      return mojom::ConnectResult::OFFSET_INVALID;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_READ_NOT_PERMITTED:
+      return mojom::ConnectResult::READ_NOT_PERMITTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_REQUEST_NOT_SUPPORTED:
+      return mojom::ConnectResult::REQUEST_NOT_SUPPORTED;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_UNKNOWN:
+      return mojom::ConnectResult::UNKNOWN;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_UNSUPPORTED_DEVICE:
+      return mojom::ConnectResult::UNSUPPORTED_DEVICE;
+    case device::BluetoothDevice::ConnectErrorCode::ERROR_WRITE_NOT_PERMITTED:
+      return mojom::ConnectResult::WRITE_NOT_PERMITTED;
+    case device::BluetoothDevice::ConnectErrorCode::NUM_CONNECT_ERROR_CODES:
+      NOTREACHED();
+      return mojom::ConnectResult::UNTRANSLATED_CONNECT_ERROR_CODE;
+  }
+  NOTREACHED();
+  return mojom::ConnectResult::UNTRANSLATED_CONNECT_ERROR_CODE;
+}
+}  // namespace
 
 Adapter::Adapter(scoped_refptr<device::BluetoothAdapter> adapter)
     : adapter_(std::move(adapter)), client_(nullptr), weak_ptr_factory_(this) {
   adapter_->AddObserver(this);
 }
 
 Adapter::~Adapter() {
   adapter_->RemoveObserver(this);
   adapter_ = nullptr;
 }
 
 void Adapter::GetInfo(const GetInfoCallback& callback) {
   mojom::AdapterInfoPtr adapter_info = mojom::AdapterInfo::New();
   adapter_info->address = adapter_->GetAddress();
   adapter_info->name = adapter_->GetName();
   adapter_info->initialized = adapter_->IsInitialized();
   adapter_info->present = adapter_->IsPresent();
   adapter_info->powered = adapter_->IsPowered();
   adapter_info->discoverable = adapter_->IsDiscoverable();
   adapter_info->discovering = adapter_->IsDiscovering();
   callback.Run(std::move(adapter_info));
 }
 
-void Adapter::GetDevice(const std::string& address,
-                        const GetDeviceCallback& callback) {
-  mojom::DevicePtr device_ptr;
-  mojo::MakeStrongBinding(base::MakeUnique<Device>(address, adapter_),
-                          mojo::GetProxy(&device_ptr));
-  callback.Run(std::move(device_ptr));
+void Adapter::ConnectToDevice(const std::string& address,
+                              const ConnectToDeviceCallback& callback) {
+  device::BluetoothDevice* device = adapter_->GetDevice(address);
+
+  if (!device) {
+    callback.Run(mojom::ConnectResult::DEVICE_NO_LONGER_IN_RANGE,
+                 nullptr /* device */);
+    return;
+  }
+
+  device->CreateGattConnection(
+      base::Bind(&Adapter::OnGattConnected, weak_ptr_factory_.GetWeakPtr(),
+                 callback),
+      base::Bind(&Adapter::OnConnectError, weak_ptr_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void Adapter::GetDevices(const GetDevicesCallback& callback) {
   std::vector<mojom::DeviceInfoPtr> devices;
 
   for (const device::BluetoothDevice* device : adapter_->GetDevices()) {
     mojom::DeviceInfoPtr device_info =
         Device::ConstructDeviceInfoStruct(device);
     devices.push_back(std::move(device_info));
   }
@@ skipping 22 matching lines @@
 }
 
 void Adapter::DeviceChanged(device::BluetoothAdapter* adapter,
                             device::BluetoothDevice* device) {
   if (client_) {
     auto device_info = Device::ConstructDeviceInfoStruct(device);
     client_->DeviceChanged(std::move(device_info));
   }
 }
 
+void Adapter::OnGattConnected(
+    const ConnectToDeviceCallback& callback,
+    std::unique_ptr<device::BluetoothGattConnection> connection) {
+  mojom::DevicePtr device_ptr;
+
+  // Owns itself.
+  new Device(adapter_, std::move(connection), mojo::GetProxy(&device_ptr));
+
+  callback.Run(mojom::ConnectResult::SUCCESS, std::move(device_ptr));
+}
+
+void Adapter::OnConnectError(
+    const ConnectToDeviceCallback& callback,
+    device::BluetoothDevice::ConnectErrorCode error_code) {
+  mojom::ConnectResult code = BluetoothErrorCodeToMojomResult(error_code);
+  callback.Run(code, nullptr /* Device */);
+}
 }  // namespace bluetooth