bluetooth: Browser-side implementation of connectGATT.

content/browser/bluetooth/bluetooth_dispatcher_host.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 "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
@@ skipping 111 matching lines @@
     }
   }
   NOTREACHED();
 }
 
 void BluetoothDispatcherHost::OnConnectGATT(
     int thread_id,
     int request_id,
     const std::string& device_instance_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  // TODO(ortuno): Add actual implementation of connectGATT. This needs to be
-  // done after the "allowed devices map" is implemented.
+
+  // TODO(ortuno): Right now it's pointless to check if the domain has access to

[scheib, 2015/05/05 04:00:43]

Find or file an issue for this security concept, reference it in comment, mark
it as blocking https://code.google.com/p/chromium/issues/detail?id=436283

+  // the device, because any domain can connect to any device. But once
+  // permissions are implemented we should check that the domain has access to
+  // the device.
+  BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+
+  // TODO(ortuno): Instead of iterating through the devices list we should keep
+  // a set and update it based on events from the adapter.

[scheib, 2015/05/05 04:00:43]

Probably we'll keep a map of origins, each with a map to allowed devices. I'm
not sure we'll need to keep a general set of devices the adapter has discovered
here, as we'll wait for scan timeout and then might as well use the set of
devices the adapter is already storing. However, the UI implementation will need
to track devices as they're discovered.

+  for (BluetoothAdapter::DeviceList::iterator iter = devices.begin();
+       iter != devices.end(); iter++) {
+    device::BluetoothDevice* device = *iter;
+    if (device->GetAddress() == device_instance_id) {
+      device->CreateGattConnection(
+          base::Bind(&BluetoothDispatcherHost::OnGATTConnectionCreated,
+                     weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
+                     device_instance_id),
+          base::Bind(&BluetoothDispatcherHost::OnCreateGATTConnectionError,
+                     weak_ptr_factory_.GetWeakPtr(), thread_id, request_id,
+                     device_instance_id));
+      return;
+    }
+  }
+  // TODO(ortuno): Change to NetworkError once it's implemented.
+  Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
+                                           BluetoothError::NOT_FOUND));
+}
+
+void BluetoothDispatcherHost::OnGATTConnectionCreated(
+    int thread_id,
+    int request_id,
+    const std::string& device_instance_id,
+    scoped_ptr<device::BluetoothGattConnection> connection) {
+  // TODO(ortuno): Save the BluetoothGattConnection so we can disconnect
+  // from it.
   Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id,
                                            device_instance_id));
 }
 
+void BluetoothDispatcherHost::OnCreateGATTConnectionError(
+    int thread_id,
+    int request_id,
+    const std::string& device_instance_id,
+    device::BluetoothDevice::ConnectErrorCode error_code) {
+  // TODO(ortuno): Change to NetworkError once it's implemented.

[scheib, 2015/05/05 04:00:43]

As we start to implement the algorithm details, let's keep references spec
sections that define the behavior and add a note in
http://webbluetoothchrome.github.io/web-bluetooth/ about the reference. Same
above.

+  Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
+                                           BluetoothError::NOT_FOUND));
+}
+
 void BluetoothDispatcherHost::OnSetBluetoothMockDataSetForTesting(
     const std::string& name) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (name == "RejectRequestDevice_NotFoundError") {
     bluetooth_mock_data_set_ = MockData::REJECT;
     bluetooth_request_device_reject_type_ = BluetoothError::NOT_FOUND;
   } else if (name == "RejectRequestDevice_SecurityError") {
     bluetooth_mock_data_set_ = MockData::REJECT;
     bluetooth_request_device_reject_type_ = BluetoothError::SECURITY;
   } else if (name == "ResolveRequestDevice_Empty" ||  // TODO(scheib): Remove.
@@ skipping 34 matching lines @@
       base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStopped,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id),
       base::Bind(&BluetoothDispatcherHost::OnDiscoverySessionStoppedError,
                  weak_ptr_factory_.GetWeakPtr(), thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStopped(int thread_id,
                                                         int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BluetoothAdapter::DeviceList devices = adapter_->GetDevices();
+
   if (devices.begin() == devices.end()) {
     Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
                                              BluetoothError::NOT_FOUND));
   } else {
     device::BluetoothDevice* device = *devices.begin();
     content::BluetoothDevice device_ipc(
         device->GetAddress(),         // instance_id
         device->GetName(),            // name
         device->GetBluetoothClass(),  // device_class
         device->GetVendorIDSource(),  // vendor_id_source
@@ skipping 10 matching lines @@
 
 void BluetoothDispatcherHost::OnDiscoverySessionStoppedError(int thread_id,
                                                              int request_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DLOG(WARNING) << "BluetoothDispatcherHost::OnDiscoverySessionStoppedError";
   Send(new BluetoothMsg_RequestDeviceError(thread_id, request_id,
                                            BluetoothError::NOT_FOUND));
 }
 
 }  // namespace content