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.
@@ skipping 706 matching lines @@
   // 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;
   }
 
-  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;
+
+    // Indicate there is one less connected 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->DecrementBluetoothConnectedDeviceCount();

[Jeffrey Yasskin, 2016/03/31 18:00:25]

Are we guaranteed that if a process crashes, it'll disconnect all of its
connections? What if the device goes out of range and the connection is lost?
Can we wind up leaking a connection count here?

[ortuno, 2016/04/04 21:20:56]

From some experimentation it seems that if the RenderProcress crashes, the
RenderProcessHost does not get notified. So we would remain connected until the
RenderProcessHost is destroyed. I hope that by moving to frame an implementing a
WebContentsObserver we can get notified of this.
This is actually not hard to solve. We would just have to keep track of the
frames that have active connections and when a device disconnects notify the
WebContents for that frame.

The part that I can't solve is hiding the indicator when the frame navigates
because we have no way of knowing of navigation events. We could try to
implement WebContentsObserver but I think that time would better spent moving to
frame.

+    }
   }
 }
 
 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);
@@ skipping 705 matching lines @@
     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);
+    web_contents->IncrementBluetoothConnectedDeviceCount();
   }
   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) {
@@ skipping 205 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