bluetooth: Remove indicator only when there are no more devices connected

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.
 
 #include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/bluetooth/bluetooth_blacklist.h"
 #include "content/browser/bluetooth/first_device_bluetooth_chooser.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 
@@ skipping 236 matching lines @@
           // directly, and change this to a reasonable discovery timeout.
           base::TimeDelta::FromSecondsD(current_delay_time_),
           base::Bind(&BluetoothDispatcherHost::StopDeviceDiscovery,
                      // base::Timer guarantees it won't call back after its
                      // destructor starts.
                      base::Unretained(this)),
           /*is_repeating=*/false),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+  connected_devices_map_.reset(new ConnectedDevicesMap(render_process_id));
+
   // Bind all future weak pointers to the UI thread.
   weak_ptr_on_ui_thread_ = weak_ptr_factory_.GetWeakPtr();
   weak_ptr_on_ui_thread_.get();  // Associates with UI thread.
 }
 
 void BluetoothDispatcherHost::OnDestruct() const {
   // See class comment: UI Thread Note.
   BrowserThread::DeleteOnUIThread::Destruct(this);
 }
 
@@ skipping 47 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();
-    device_id_to_connection_map_.clear();
+    connected_devices_map_.reset(new ConnectedDevicesMap(render_process_id_));
     allowed_devices_map_ = BluetoothAllowedDevicesMap();
   }
 
   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 84 matching lines @@
         service_uuid(service_uuid),
         func(func) {}
   ~PrimaryServicesRequest() {}
 
   int thread_id;
   int request_id;
   std::string service_uuid;
   CallingFunction func;
 };
 
+BluetoothDispatcherHost::ConnectedDevicesMap::ConnectedDevicesMap(
+    int render_process_id)
+    : render_process_id_(render_process_id) {}
+
+BluetoothDispatcherHost::ConnectedDevicesMap::~ConnectedDevicesMap() {
+  for (auto frame_id_device_id : frame_ids_device_ids_) {
+    DecrementBluetoothConnectedDeviceCount(frame_id_device_id.first);
+  }
+}
+
+bool BluetoothDispatcherHost::ConnectedDevicesMap::HasActiveConnection(
+    const std::string& device_id) {
+  auto connection_iter = device_id_to_connection_map_.find(device_id);
+  if (connection_iter != device_id_to_connection_map_.end()) {
+    return connection_iter->second->IsConnected();
+  }
+  return false;
+}
+
+void BluetoothDispatcherHost::ConnectedDevicesMap::InsertOrReplace(
+    int frame_routing_id,
+    const std::string& device_id,
+    scoped_ptr<device::BluetoothGattConnection> connection) {
+  auto connection_iter = device_id_to_connection_map_.find(device_id);
+  if (connection_iter == device_id_to_connection_map_.end()) {
+    IncrementBluetoothConnectedDeviceCount(frame_routing_id);
+    frame_ids_device_ids_.insert(std::make_pair(frame_routing_id, device_id));
+  } else {
+    device_id_to_connection_map_.erase(connection_iter);
+  }
+  device_id_to_connection_map_[device_id] = std::move(connection);
+}
+
+void BluetoothDispatcherHost::ConnectedDevicesMap::Remove(
+    int frame_routing_id,
+    const std::string& device_id) {
+  if (device_id_to_connection_map_.erase(device_id)) {
+    VLOG(1) << "Disconnecting device: " << device_id;
+    DecrementBluetoothConnectedDeviceCount(frame_routing_id);
+    frame_ids_device_ids_.erase(std::make_pair(frame_routing_id, device_id));
+  }
+}
+
+void BluetoothDispatcherHost::ConnectedDevicesMap::
+    IncrementBluetoothConnectedDeviceCount(int frame_routing_id) {
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
+  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
+      WebContents::FromRenderFrameHost(render_frame_host));
+  if (web_contents) {
+    web_contents->IncrementBluetoothConnectedDeviceCount();
+  }
+}
+
+void BluetoothDispatcherHost::ConnectedDevicesMap::
+    DecrementBluetoothConnectedDeviceCount(int frame_routing_id) {
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
+  WebContentsImpl* web_contents = static_cast<WebContentsImpl*>(
+      WebContents::FromRenderFrameHost(render_frame_host));
+  if (web_contents) {
+    web_contents->DecrementBluetoothConnectedDeviceCount();
+  }
+}
+
 void BluetoothDispatcherHost::set_adapter(
     scoped_refptr<device::BluetoothAdapter> adapter) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (adapter_.get())
     adapter_->RemoveObserver(this);
   adapter_ = adapter;
   if (adapter_.get())
     adapter_->AddObserver(this);
 }
 
@@ skipping 204 matching lines @@
       QueryCacheForDevice(GetOrigin(frame_routing_id), device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordConnectGATTOutcome(query_result.outcome);
     Send(new BluetoothMsg_GATTServerConnectError(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_GATTServerConnectSuccess(thread_id, request_id));
-      return;
-    }
+  if (connected_devices_map_->HasActiveConnection(device_id)) {
+    VLOG(1) << "Already connected.";
+    Send(new BluetoothMsg_GATTServerConnectSuccess(thread_id, request_id));
+    return;
   }
 
   query_result.device->CreateGattConnection(
       base::Bind(&BluetoothDispatcherHost::OnGATTConnectionCreated,
                  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::OnGATTServerDisconnect(
     int thread_id,
     int frame_routing_id,
     const std::string& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       UMAWebBluetoothFunction::REMOTE_GATT_SERVER_DISCONNECT);
 
   // Frames can send a disconnect request after they've started navigating,
   // making calls to GetLastCommitted origin invalid. Because we still need
   // to disconnect the device, otherwise we would leave users with no other
   // option to disconnect than closing the tab, we purposefully don't
   // check if the frame has permission to interact with the device.
 
-  RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
-  WebContents* web_contents =
-      WebContents::FromRenderFrameHost(render_frame_host);
-  if (web_contents) {
-    web_contents->SetBluetoothDeviceConnected(false);
-  }
-
   // The last BluetoothGattConnection for a device closes the connection when
   // it's destroyed.
-  if (device_id_to_connection_map_.erase(device_id)) {
-    VLOG(1) << "Disconnecting device: " << device_id;
-  }
+
+  // This only catches disconnections from the renderer. If the device
+  // disconnects by itself, or the renderer frame has been deleted
+  // due to navigation, we will not hide the indicator.
+  // TODO(ortuno): Once we move to Frame and Mojo we will be able
+  // to observe the frame's lifetime and hide the indicator when necessary.
+  // http://crbug.com/508771
+  connected_devices_map_->Remove(frame_routing_id, 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);
@@ skipping 667 matching lines @@
 }
 
 void BluetoothDispatcherHost::OnGATTConnectionCreated(
     int thread_id,
     int request_id,
     int frame_routing_id,
     const std::string& device_id,
     base::TimeTicks start_time,
     scoped_ptr<device::BluetoothGattConnection> connection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  device_id_to_connection_map_[device_id] = std::move(connection);
   RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
   RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
-  RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
-  WebContents* web_contents =
-      WebContents::FromRenderFrameHost(render_frame_host);
-  if (web_contents) {
-    web_contents->SetBluetoothDeviceConnected(true);
-  }
+  connected_devices_map_->InsertOrReplace(frame_routing_id, device_id,
+                                          std::move(connection));
   Send(new BluetoothMsg_GATTServerConnectSuccess(thread_id, request_id));
 }
 
 void BluetoothDispatcherHost::OnCreateGATTConnectionError(
     int thread_id,
     int request_id,
     const std::string& device_id,
     base::TimeTicks start_time,
     device::BluetoothDevice::ConnectErrorCode error_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 186 matching lines @@
 
 bool BluetoothDispatcherHost::CanFrameAccessCharacteristicInstance(
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   return QueryCacheForCharacteristic(GetOrigin(frame_routing_id),
                                      characteristic_instance_id)
              .outcome != CacheQueryOutcome::BAD_RENDERER;
 }
 
 }  // namespace content