Remove outdated devices from Android device chooser

device/bluetooth/bluetooth_adapter.h

 // Copyright (c) 2012 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 DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 405 matching lines @@
   void NotifyGattCharacteristicRemoved(
       BluetoothGattCharacteristic* characteristic);
   void NotifyGattDescriptorAdded(BluetoothGattDescriptor* descriptor);
   void NotifyGattDescriptorRemoved(BluetoothGattDescriptor* descriptor);
   void NotifyGattCharacteristicValueChanged(
       BluetoothGattCharacteristic* characteristic,
       const std::vector<uint8_t>& value);
   void NotifyGattDescriptorValueChanged(BluetoothGattDescriptor* descriptor,
                                         const std::vector<uint8_t>& value);
 
+  // Removes from |devices_| any previously paired, connected or seen
+  // devices which are no longer present. Notifies observers. Note:
+  // this is only used by platforms where there is no notification of
+  // lost devices.
+  void RemoveTimedOutDevices();

[scheib, 2016/04/07 22:05:02]

This seems odd to me to be called externally. Instead, should a recurring posted
task be run inside the implementation? Similar to how Mac was?

[perja, 2016/04/08 07:47:35]

Yeah, we could do that instead I guess. The recurring task seemed a bit overkill
for this since we only need to purge the cache before the device chooser is
populated, but maybe it isn't that bad. I will look at it again.

[scheib, 2016/04/12 05:01:57]

Tricky. Because it doesn't affect only the cache. It also sends notifications
that the device is removed. So, e.g. code that responds to devices being removed
would behave differently if other code calls RemoveTimedOutDevices explicitly or
not.

Also, because on Mac there's a timer, but clearly we want only one timer for all
timer based operations such as this. So perhaps it simply becomes each platform
implementation's job to setup a timer if necessary for that platform and to call
'PoolAdapter' or equiv. 

+
+  // The timeout in seconds used by RemoveTimedOutDevices.
+  static const base::TimeDelta timeoutSec;
+
  protected:
   friend class base::RefCounted<BluetoothAdapter>;
   friend class BluetoothDiscoverySession;
   friend class BluetoothTestBase;
 
   typedef base::ScopedPtrHashMap<std::string, scoped_ptr<BluetoothDevice>>
       DevicesMap;
   typedef std::pair<BluetoothDevice::PairingDelegate*, PairingDelegatePriority>
       PairingDelegatePair;
   typedef base::Callback<void(UMABluetoothDiscoverySessionOutcome)>
@@ skipping 118 matching lines @@
   std::set<BluetoothDiscoverySession*> discovery_sessions_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BluetoothAdapter> weak_ptr_factory_;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_ADAPTER_H_