bluetooth: Add disconnect function

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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
@@ skipping 261 matching lines @@
   // See class comment: UI Thread Note.
   *thread = BrowserThread::UI;
 }
 
 bool BluetoothDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BluetoothDispatcherHost, message)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_RequestDevice, OnRequestDevice)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_ConnectGATT, OnConnectGATT)
+  IPC_MESSAGE_HANDLER(BluetoothHostMsg_Disconnect, OnDisconnect)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetPrimaryService, OnGetPrimaryService)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_GetCharacteristic, OnGetCharacteristic)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_ReadValue, OnReadValue)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_WriteValue, OnWriteValue)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_StartNotifications, OnStartNotifications)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_StopNotifications, OnStopNotifications)
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_RegisterCharacteristic,
                       OnRegisterCharacteristicObject);
   IPC_MESSAGE_HANDLER(BluetoothHostMsg_UnregisterCharacteristic,
                       OnUnregisterCharacteristicObject);
@@ skipping 22 matching lines @@
     DCHECK(pending_primary_services_requests_.empty());
 
     // The following data structures are cleaned up when a
     // device/service/characteristic is removed.
     // Since this can happen after the test is done and the cleanup function is
     // called, we clean them here.
     service_to_device_.clear();
     characteristic_to_service_.clear();
     characteristic_id_to_notify_session_.clear();
     active_characteristic_threads_.clear();
-    connections_.clear();
+    device_id_to_connection_map_.clear();
     devices_with_discovered_services_.clear();
   }
 
   set_adapter(std::move(mock_adapter));
 }
 
 BluetoothDispatcherHost::~BluetoothDispatcherHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Clear adapter, releasing observer references.
   set_adapter(scoped_refptr<device::BluetoothAdapter>());
@@ skipping 93 matching lines @@
 
   int thread_id;
   int request_id;
   std::string service_uuid;
   CallingFunction func;
 };
 
 void BluetoothDispatcherHost::set_adapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  connections_.clear();
   if (adapter_.get())
     adapter_->RemoveObserver(this);
   adapter_ = adapter;
   if (adapter_.get())
     adapter_->AddObserver(this);
 }
 
 void BluetoothDispatcherHost::StartDeviceDiscovery(
     RequestDeviceSession* session,
     int chooser_id) {
@@ skipping 279 matching lines @@
   const CacheQueryResult query_result =
       QueryCacheForDevice(GetOrigin(frame_routing_id), device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordConnectGATTOutcome(query_result.outcome);
     Send(new BluetoothMsg_ConnectGATTError(thread_id, request_id,
                                            query_result.GetWebError()));
     return;
   }
 
+  // If we are already connected no need to connect again.
+  auto connection_iter = device_id_to_connection_map_.find(device_id);
+  if (connection_iter != device_id_to_connection_map_.end()) {
+    if (connection_iter->second->IsConnected()) {
+      VLOG(1) << "Already connected.";
+      Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id,
+                                               device_id));
+      return;
+    }
+  }
+
   query_result.device->CreateGattConnection(
       base::Bind(&BluetoothDispatcherHost::OnGATTConnectionCreated,
-                 weak_ptr_on_ui_thread_, thread_id, request_id, device_id,
-                 start_time),
+                 weak_ptr_on_ui_thread_, thread_id, request_id,
+                 frame_routing_id, device_id, start_time),
       base::Bind(&BluetoothDispatcherHost::OnCreateGATTConnectionError,
                  weak_ptr_on_ui_thread_, thread_id, request_id, device_id,
                  start_time));
 }
 
+void BluetoothDispatcherHost::OnDisconnect(int thread_id,
+                                           int frame_routing_id,
+                                           const std::string& device_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RecordWebBluetoothFunctionCall(
+      UMAWebBluetoothFunction::REMOTE_GATT_SERVER_DISCONNECT);
+
+  // Make sure the origin is allowed to access the device. We perform this check
+  // in case a hostile renderer is trying to disconnect a device that the
+  // renderer is not allowed to access.
+  if (allowed_devices_map_.GetDeviceAddress(GetOrigin(frame_routing_id),
+                                            device_id)
+          .empty()) {
+    bad_message::ReceivedBadMessage(
+        this, bad_message::BDH_DEVICE_NOT_ALLOWED_FOR_ORIGIN);
+    return;
+  }
+
+  // The last BluetoothGattConnection for a device closes the connection when
+  // it's destroyed.
+  if (device_id_to_connection_map_.erase(device_id)) {

[Jeffrey Yasskin, 2016/01/14 22:13:18]

What happens if the OnDisconnect comes in after CreateGattConnection() was
called, but before it calls OnGATTConnectionCreated?

It should probably result in any connection getting disconnected.

[ortuno, 2016/01/15 01:00:08]

As discussed, we should do this once we can cancel pending connection attempts
since it will make it much easier.

[Jeffrey Yasskin, 2016/01/15 01:12:19]

Yep.

+    VLOG(1) << "Disconnecting device: " << device_id;
+  }
+}
+
 void BluetoothDispatcherHost::OnGetPrimaryService(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::string& device_id,
     const std::string& service_uuid) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_PRIMARY_SERVICE);
   RecordGetPrimaryServiceService(BluetoothUUID(service_uuid));
 
@@ skipping 425 matching lines @@
           device->GetUUIDs()));  // uuids
   RecordRequestDeviceOutcome(UMARequestDeviceOutcome::SUCCESS);
   Send(new BluetoothMsg_RequestDeviceSuccess(session->thread_id,
                                              session->request_id, device_ipc));
   request_device_sessions_.Remove(chooser_id);
 }
 
 void BluetoothDispatcherHost::OnGATTConnectionCreated(
     int thread_id,
     int request_id,
+    int frame_routing_id,

[Jeffrey Yasskin, 2016/01/14 22:13:18]

It looks like you don't actually need this argument.

[ortuno, 2016/01/15 01:00:08]

Done.

     const std::string& device_id,
     base::TimeTicks start_time,
     scoped_ptr<device::BluetoothGattConnection> connection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  connections_.push_back(std::move(connection));
+  device_id_to_connection_map_[device_id] = std::move(connection);
   RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
   RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
   Send(new BluetoothMsg_ConnectGATTSuccess(thread_id, request_id, device_id));
 }
 
 void BluetoothDispatcherHost::OnCreateGATTConnectionError(
     int thread_id,
     int request_id,
     const std::string& device_id,
     base::TimeTicks start_time,
@@ skipping 217 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowNeedLocationLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content