Remove outdated devices from Android device chooser

device/bluetooth/bluetooth_adapter_android.cc

 // Copyright 2015 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.
 
 #include "device/bluetooth/bluetooth_adapter_android.h"
 
 #include <memory>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
+#include "base/bind.h"
+#include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "device/bluetooth/android/wrappers.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
 #include "device/bluetooth/bluetooth_device_android.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "jni/ChromeBluetoothAdapter_jni.h"
 
 using base::android::AttachCurrentThread;
@@ skipping 10 matching lines @@
 
 // static
 base::WeakPtr<BluetoothAdapterAndroid> BluetoothAdapterAndroid::Create(
     jobject bluetooth_adapter_wrapper) {  // Java Type: bluetoothAdapterWrapper
   BluetoothAdapterAndroid* adapter = new BluetoothAdapterAndroid();
 
   adapter->j_adapter_.Reset(Java_ChromeBluetoothAdapter_create(
       AttachCurrentThread(), reinterpret_cast<intptr_t>(adapter),
       bluetooth_adapter_wrapper));
 
+  adapter->ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  adapter->PurgeTimedOutDevices();

[ortuno, 2016/06/14 15:29:33]

I don't think we want to be purging devices all the time. This should only be
called after we start a scan. To do this we will have move the start scan logic
from ChromeBluetoothAdapter.addDiscoverySession to
BluetoothAdapterAndroid::AddDiscoverySession.

[perja, 2016/06/15 13:03:40]

Acknowledged.

+
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 // static
 bool BluetoothAdapterAndroid::RegisterJNI(JNIEnv* env) {
   return RegisterNativesImpl(env);  // Generated in BluetoothAdapter_jni.h
 }
 
 std::string BluetoothAdapterAndroid::GetAddress() const {
   return ConvertJavaStringToUTF8(Java_ChromeBluetoothAdapter_getAddress(
@@ skipping 117 matching lines @@
     const JavaParamRef<jobject>&
         advertised_uuids) {  // Java Type: List<ParcelUuid>
   std::string device_address = ConvertJavaStringToUTF8(env, address);
   DevicesMap::const_iterator iter = devices_.find(device_address);
 
   if (iter == devices_.end()) {
     // New device.
     BluetoothDeviceAndroid* device_android =
         BluetoothDeviceAndroid::Create(this, bluetooth_device_wrapper);
     device_android->UpdateAdvertisedUUIDs(advertised_uuids);
+    device_android->UpdateTimestamp();
     devices_.add(device_address,
                  std::unique_ptr<BluetoothDevice>(device_android));
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       DeviceAdded(this, device_android));
   } else {
     // Existing device.
     BluetoothDeviceAndroid* device_android =
         static_cast<BluetoothDeviceAndroid*>(iter->second);
+    device_android->UpdateTimestamp();
     if (device_android->UpdateAdvertisedUUIDs(advertised_uuids)) {
       FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                         DeviceChanged(this, device_android));
     }
   }
 }
 
 BluetoothAdapterAndroid::BluetoothAdapterAndroid() : weak_ptr_factory_(this) {
 }
 
 BluetoothAdapterAndroid::~BluetoothAdapterAndroid() {
   Java_ChromeBluetoothAdapter_onBluetoothAdapterAndroidDestruction(
       AttachCurrentThread(), j_adapter_.obj());
 }
 
+void BluetoothAdapterAndroid::PurgeTimedOutDevices() {
+  RemoveTimedOutDevices();
+  int pollIntervalMs = 11000;

[ortuno, 2016/06/14 15:29:33]

Make these enums:

namespace {
  // TODO add a comment explaining the values.
  enum { kPassivePollInterval = 11000 };
  enum { kActivePollInterval = 1000 };
}

[perja, 2016/06/15 13:03:40]

Acknowledged.

+  if (IsDiscovering()) {
+    pollIntervalMs = 1000;
+  }
+  ui_task_runner_->PostDelayedTask(

[ortuno, 2016/06/14 15:29:33]

I think what Vince was suggesting was that we run RemoveTimedOutDevices every
second as long as there is an active discovery session but once the discovery
session is finished we run RemoveTimedOutDevices once after 11 seconds. This can
be done with the following code:

if (IsDiscovering()) {
  ui_task_runner_->PostDelayedTask(
      FROM_HERE, base::Bind(&BluetoothAdapterAndroid::PurgeTimedOutDevices,
                            weak_ptr_factory_.GetWeakPtr()),
      base::TimeDelta::FromMilliseconds(kActivePollInterval));
} else {
  ui_task_runner_->PostDelayedTask(
      FROM_HERE, base::Bind(&BluetoothAdapterAndroid::RemoveTimedOutDevices,
                            weak_ptr_factory_.GetWeakPtr()),
      base::TimeDelta::FromMilliseconds(kPassivePollInterval));
}

[perja, 2016/06/15 13:03:40]

Acknowledged.

+      FROM_HERE, base::Bind(&BluetoothAdapterAndroid::PurgeTimedOutDevices,
+                            weak_ptr_factory_.GetWeakPtr()),
+      base::TimeDelta::FromMilliseconds(pollIntervalMs));
+}
+
 void BluetoothAdapterAndroid::AddDiscoverySession(
     BluetoothDiscoveryFilter* discovery_filter,
     const base::Closure& callback,
     const DiscoverySessionErrorCallback& error_callback) {
   // TODO(scheib): Support filters crbug.com/490401
   if (Java_ChromeBluetoothAdapter_addDiscoverySession(AttachCurrentThread(),
                                                       j_adapter_.obj())) {
     callback.Run();
   } else {
     // TODO(scheib): Eventually wire the SCAN_FAILED result through to here.
@@ skipping 21 matching lines @@
   // TODO(scheib): Support filters crbug.com/490401
   NOTIMPLEMENTED();
   error_callback.Run(UMABluetoothDiscoverySessionOutcome::NOT_IMPLEMENTED);
 }
 
 void BluetoothAdapterAndroid::RemovePairingDelegateInternal(
     device::BluetoothDevice::PairingDelegate* pairing_delegate) {
 }
 
 }  // namespace device