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 82 matching lines @@
                                              BluetoothError::NOT_FOUND));
   }
   return;
 }
 
 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.
-  Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id,
-                                           device_instance_id));
+  // TODO(ortuno): Right now it's pointless to check if the domain has access to
+  // 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. https://crbug.com/484745
+  device::BluetoothDevice* device = adapter_->GetDevice(device_instance_id);
+  if (device == NULL) {
+    // Since we can't create a ATT Bearer without a device we reject with
+    // NetworkError.

[Jeffrey Yasskin, 2015/05/20 22:19:48]

Is a device_instance_id that doesn't map to a device something that a valid
renderer would do? It seems like renderers should really just be reflecting
instance IDs back to the browser, and if they send an instance ID that the
browser has never seen before, the right thing to do is to infer that the
renderer is hostile and kill it.

Maybe comment what would cause a null device given a valid instance ID?

[ortuno, 2015/05/20 23:35:19]

Yes, the renderer could send a device_instance_id that is no longer in
BluetoothAdapter. For example a user chooses a device which is then returned by
requestDevice. If the user walks away from the device and the device is no
longer in range the device will no longer be in BluetoothAdapter by the time JS
tries to connect to the device.

[Jeffrey Yasskin, 2015/05/21 00:12:00]

And walking out of range is exactly when we'd want to return NetworkError.
Sounds good. :)

+    // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
+    Send(new BluetoothMsg_ConnectGATTError(thread_id, request_id,
+                                           BluetoothError::NETWORK_ERROR));
+    return;
+  }
+  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));
 }
 
 void BluetoothDispatcherHost::OnDiscoverySessionStarted(
     int thread_id,
     int request_id,
     scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BluetoothDispatcherHost::StopDiscoverySession,
@@ skipping 48 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));
 }
 
+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) {
+  // There was an error creating the ATT Bearer so we reject with
+  // NetworkError.

[Jeffrey Yasskin, 2015/05/20 22:19:48]

Please give the eventual Javascript error a descriptive message so that
developers can debug their connection errors. The message isn't specified in the
standard, but that's a place each browser should try to do its best.

[ortuno, 2015/05/20 23:35:19]

Added a todo and opened an issue: http://crbug.com/490419

+  // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothdevice-connectgatt
+  Send(new BluetoothMsg_ConnectGATTError(thread_id, request_id,
+                                         BluetoothError::NETWORK_ERROR));
+}
+
 }  // namespace content