bluetooth: mac: Improve classic device discovery and update

device/bluetooth/bluetooth_discovery_manager_mac.mm

 // 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.
 
 #include "device/bluetooth/bluetooth_discovery_manager_mac.h"
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothDeviceInquiry.h>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/macros.h"
+#include "base/timer/timer.h"
 
 namespace device {
 
 class BluetoothDiscoveryManagerMacClassic;
 
 }  // namespace device
 
 // IOBluetoothDeviceInquiryDelegate implementation.
 @interface BluetoothDeviceInquiryDelegate
     : NSObject<IOBluetoothDeviceInquiryDelegate> {
  @private
   device::BluetoothDiscoveryManagerMacClassic* manager_;  // weak
 }
 
 - (id)initWithManager:(device::BluetoothDiscoveryManagerMacClassic*)manager;
 
 @end
 
 namespace device {
 
+// 1 second between cache clean ups is a good compromise between latency and
+// performance.
+const int kCleanCacheTimer = 1;

[Jeffrey Yasskin, 2016/09/13 20:58:05]

I think you can use a global constexpr TimeDelta now.

[ortuno, 2016/09/14 04:48:25]

Argh, I always forget that we should use TimeDelta instead of ints. Done.

+
 // ementation of BluetoothDiscoveryManagerMac for Bluetooth classic device
 // discovery, using the IOBluetooth framework.
 class BluetoothDiscoveryManagerMacClassic
     : public BluetoothDiscoveryManagerMac {
  public:
   explicit BluetoothDiscoveryManagerMacClassic(Observer* observer)
       : BluetoothDiscoveryManagerMac(observer),
         should_do_discovery_(false),
         inquiry_running_(false),
         inquiry_delegate_(
             [[BluetoothDeviceInquiryDelegate alloc] initWithManager:this]),
         inquiry_([[IOBluetoothDeviceInquiry alloc]
-            initWithDelegate:inquiry_delegate_]) {}
+            initWithDelegate:inquiry_delegate_]),
+        clean_cache_timer_(
+            FROM_HERE,
+            base::TimeDelta::FromSeconds(kCleanCacheTimer),
+            base::Bind(
+                &BluetoothDiscoveryManagerMacClassic::CleanFoundDevicesCache,
+                // base::Timer guarantees it won't call back after its
+                // destructor starts.
+                base::Unretained(this)),
+            true /* is_repeating */) {}
 
   ~BluetoothDiscoveryManagerMacClassic() override {}
 
   // BluetoothDiscoveryManagerMac override.
   bool IsDiscovering() const override { return should_do_discovery_; }
 
   // BluetoothDiscoveryManagerMac override.
   bool StartDiscovery() override {
     DVLOG(1) << "Bluetooth Classic: StartDiscovery";
     DCHECK(!should_do_discovery_);
@@ skipping 10 matching lines @@
     if ([inquiry_ start] != kIOReturnSuccess) {
       DVLOG(1) << "Failed to start device inquiry";
 
       // Set |should_do_discovery_| to false here. Since we're reporting an
       // error, we're indicating that the adapter call StartDiscovery again
       // if needed.
       should_do_discovery_ = false;
       return false;
     }
 
+    clean_cache_timer_.Reset();
     DVLOG(1) << "Device inquiry start was successful";
     return true;
   }
 
   // BluetoothDiscoveryManagerMac override.
   bool StopDiscovery() override {
     DVLOG(1) << "Bluetooth Classic: StopDiscovery";
     DCHECK(should_do_discovery_);
 
     should_do_discovery_ = false;
 
     if (!inquiry_running_) {
       DVLOG(1) << "No device inquiry running; discovery stopped";
       return true;
     }
 
     DVLOG(1) << "Requesting to stop device inquiry";
+    CleanFoundDevicesCache();
+    clean_cache_timer_.Stop();
+
     IOReturn status = [inquiry_ stop];
     if (status == kIOReturnSuccess) {
       DVLOG(1) << "Device inquiry stop was successful";
       return true;
     }
 
     if (status == kIOReturnNotPermitted) {
       DVLOG(1) << "Device inquiry was already stopped";
       return true;
     }
@@ skipping 55 matching lines @@
       return;
     }
 
     DVLOG(1) << "Failed to restart discovery";
     should_do_discovery_ = false;
     DCHECK(observer_);
     observer_->ClassicDiscoveryStopped(true /* unexpected */);
   }
 
  private:
+  void CleanFoundDevicesCache() { [inquiry_ clearFoundDevices]; }
+
   // The requested discovery state.
   bool should_do_discovery_;
 
   // The current inquiry state.
   bool inquiry_running_;
 
   // Objective-C objects for running and tracking device inquiry.
   base::scoped_nsobject<BluetoothDeviceInquiryDelegate> inquiry_delegate_;
   base::scoped_nsobject<IOBluetoothDeviceInquiry> inquiry_;
 
+  // Timer to clean up the cache. That way we get notified every time a device
+  // is seen.
+  base::Timer clean_cache_timer_;
+
   DISALLOW_COPY_AND_ASSIGN(BluetoothDiscoveryManagerMacClassic);
 };
 
 BluetoothDiscoveryManagerMac::BluetoothDiscoveryManagerMac(
     Observer* observer) : observer_(observer) {
   DCHECK(observer);
 }
 
 BluetoothDiscoveryManagerMac::~BluetoothDiscoveryManagerMac() {
 }
@@ skipping 25 matching lines @@
   manager_->DeviceFound(sender, device);
 }
 
 - (void)deviceInquiryComplete:(IOBluetoothDeviceInquiry*)sender
                         error:(IOReturn)error
                       aborted:(BOOL)aborted {
   manager_->DeviceInquiryComplete(sender, error, aborted);
 }
 
 @end