bluetooth: Show tab indicator when BT device is 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 678 matching lines @@
   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;
     }
   }
 
   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::OnGATTServerDisconnect(
     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;
   }
 
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(render_process_id_, frame_routing_id);
+  WebContents* web_contents =
+      WebContents::FromRenderFrameHost(render_frame_host);
+  if (render_frame_host && web_contents) {

[miu, 2016/03/04 23:42:37]

nit: Not necessary to test render_frame_host, since web_contents will be null if
render_frame_host was null when the WC was looked-up.

[ortuno, 2016/03/14 20:52:50]

Done.

+    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;
   }
 }
 
 void BluetoothDispatcherHost::OnGetPrimaryService(
     int thread_id,
     int request_id,
@@ skipping 698 matching lines @@
           filtered_uuids));  // 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,
     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 (render_frame_host && web_contents) {

[miu, 2016/03/04 23:42:37]

nit: ditto--no need for render_frame_host

[ortuno, 2016/03/14 20:52:50]

Done.

+    web_contents->SetBluetoothDeviceConnected(true);
+  }
   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 204 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