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

content/browser/bluetooth/bluetooth_dispatcher_host.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DISPATCHER_HOST_H_
 #define CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DISPATCHER_HOST_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 70 matching lines @@
  protected:
   ~BluetoothDispatcherHost() override;
 
  private:
   friend class base::DeleteHelper<BluetoothDispatcherHost>;
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
 
   struct RequestDeviceSession;
   struct PrimaryServicesRequest;
 
+  // Map to keep track of connections. Inserting and removing connections
+  // will update the Web Contents for the frame. Upon destruction
+  // the map will clear Web Contents of Bluetooth connections.
+  struct ConnectedDevicesMap {
+    ConnectedDevicesMap(int render_process_id);
+    ~ConnectedDevicesMap();
+    bool HasActiveConnection(const std::string& device_id);
+    void InsertOrReplace(
+        int frame_routing_id,
+        const std::string& device_id,
+        scoped_ptr<device::BluetoothGattConnection> connection);
+    void Remove(int frame_routing_id, const std::string& device_id);
+    void IncrementBluetoothConnectedDeviceCount(int frame_routing_id);
+    void DecrementBluetoothConnectedDeviceCount(int frame_routing_id);
+
+    int render_process_id_;
+    std::unordered_map<std::string, scoped_ptr<device::BluetoothGattConnection>>
+        device_id_to_connection_map_;
+    // Keeps track of which frame is connected to which device so that
+    // we can clean up the WebContents in our destructor.
+    std::set<std::pair<int, std::string>> frame_ids_device_ids_;
+  };
+
   // Set |adapter_| to a BluetoothAdapter instance and register observers,
   // releasing references to previous |adapter_|.
   void set_adapter(scoped_refptr<device::BluetoothAdapter> adapter);
 
   // Makes sure a BluetoothDiscoverySession is active for |session|, and resets
   // its timeout.
   void StartDeviceDiscovery(RequestDeviceSession* session, int chooser_id);
 
   // Stops all BluetoothDiscoverySessions being run for requestDevice()
   // choosers.
@@ skipping 210 matching lines @@
   // A BluetoothAdapter instance representing an adapter of the system.
   scoped_refptr<device::BluetoothAdapter> adapter_;
 
   // Automatically stops Bluetooth discovery a set amount of time after it was
   // started. We have a single timer for all of Web Bluetooth because it's
   // simpler than tracking timeouts for each RequestDeviceSession individually,
   // and because there's no harm in extending the length of a few discovery
   // sessions when other sessions are active.
   base::Timer discovery_session_timer_;
 
-  // Retain BluetoothGattConnection objects to keep connections open.
-  std::map<std::string, scoped_ptr<device::BluetoothGattConnection>>
-      device_id_to_connection_map_;
+  // Retains BluetoothGattConnection objects to keep connections open.
+  scoped_ptr<ConnectedDevicesMap> connected_devices_map_;
 
   // Map of device_address's to primary-services requests that need responses
   // when that device's service discovery completes.
   std::map<std::string, std::vector<PrimaryServicesRequest>>
       pending_primary_services_requests_;
 
   // |weak_ptr_on_ui_thread_| provides weak pointers, e.g. for callbacks, and
   // because it exists and has been bound to the UI thread enforces that all
   // copies verify they are also used on the UI thread.
   base::WeakPtr<BluetoothDispatcherHost> weak_ptr_on_ui_thread_;
   base::WeakPtrFactory<BluetoothDispatcherHost> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothDispatcherHost);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DISPATCHER_HOST_H_