bluetooth: Implement hardware filtering on macOS

device/bluetooth/bluetooth_low_energy_discovery_manager_mac.mm

 // 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_low_energy_discovery_manager_mac.h"
 
 #include <memory>
 
 #include "base/mac/mac_util.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/strings/sys_string_conversions.h"
 #include "device/bluetooth/bluetooth_adapter_mac.h"
 #include "device/bluetooth/bluetooth_low_energy_device_mac.h"
 
 namespace device {
 
 BluetoothLowEnergyDiscoveryManagerMac::
     ~BluetoothLowEnergyDiscoveryManagerMac() {
 }
 
 bool BluetoothLowEnergyDiscoveryManagerMac::IsDiscovering() const {
   return discovering_;
 }
 
 void BluetoothLowEnergyDiscoveryManagerMac::StartDiscovery(
-    BluetoothDevice::UUIDList services_uuids) {
-  discovering_ = true;
-  pending_ = true;
-  services_uuids_ = services_uuids;
-  TryStartDiscovery();
+    std::set<BluetoothUUID> services_uuids) {

[Jeffrey Yasskin, 2016/08/23 21:37:04]

Since this doesn't modify the input argument, it should probably take a const
std::set<BluetoothUUID>& instead of by-value. Also, a vector<> or
unordered_set<> would be more efficient: do they make sense as the argument
type?

+  // Update Scan UUIDs.
+  bool should_update_scan = false;
+  for (const auto& uuid : services_uuids) {
+    size_t& count = scan_uuids_to_filter_count_[uuid];
+    count++;
+
+    if (count == 1) {
+      should_update_scan = true;
+    }
+  }
+
+  // Try to scan only if there are new services or we haven't
+  // started discovery yet.
+  if (should_update_scan || !discovering_) {

[Jeffrey Yasskin, 2016/08/23 21:37:04]

If we're not discovering, but there are no services to scan for, shouldn't we
keep not discovering?

+    pending_ = true;
+    discovering_ = true;
+    TryStartDiscovery();
+  }
 }
 
 void BluetoothLowEnergyDiscoveryManagerMac::TryStartDiscovery() {
   if (!discovering_) {
     VLOG(1) << "TryStartDiscovery !discovering_";
     return;
   }
 
   if (!pending_) {
     VLOG(1) << "TryStartDiscovery !pending_";
     return;
   }
 
   if (!central_manager_) {
     VLOG(1) << "TryStartDiscovery !central_manager_";
     return;
   }
 
   if ([central_manager_ state] != CBCentralManagerStatePoweredOn) {
     VLOG(1) << "TryStartDiscovery != CBCentralManagerStatePoweredOn";
     return;
   }
 
   // Converts the services UUIDs to a CoreBluetooth data structure.
   NSMutableArray* services = nil;
-  if (!services_uuids_.empty()) {
+  if (!scan_uuids_to_filter_count_.empty()) {
     services = [NSMutableArray array];
-    for (auto& service_uuid : services_uuids_) {
-      NSString* uuidString =
-          base::SysUTF8ToNSString(service_uuid.canonical_value().c_str());
+    VLOG(1) << "Scanning for UUIDs: ";
+    for (const auto& uuid_to_count : scan_uuids_to_filter_count_) {
+      const std::string& uuid_str = uuid_to_count.first.canonical_value();
+      VLOG(1) << uuid_str;
+      NSString* uuidString = base::SysUTF8ToNSString(uuid_str.c_str());
       CBUUID* uuid = [CBUUID UUIDWithString:uuidString];
       [services addObject:uuid];
     }
   };
 
   VLOG(1) << "TryStartDiscovery scanForPeripheralsWithServices";
   // Start a scan with the Allow Duplicates option so that we get notified
   // of each new Advertisement Packet. This allows us to provide up to date
   // values for RSSI, Advertised Services, Advertised Data, etc.
   [central_manager_
       scanForPeripheralsWithServices:services
                              options:@{
                                CBCentralManagerScanOptionAllowDuplicatesKey :
                                    @YES
                              }];
   pending_ = false;
 }
 
+void BluetoothLowEnergyDiscoveryManagerMac::RemoveDiscoveryUUIDs(
+    std::set<BluetoothUUID> uuids_to_remove) {
+  bool did_remove_service = false;
+  for (const auto& uuid_to_remove : uuids_to_remove) {
+    auto it = scan_uuids_to_filter_count_.find(uuid_to_remove);
+    DCHECK(it != scan_uuids_to_filter_count_.end());
+    DCHECK_LT(0u, it->second);
+    it->second--;
+    if (it->second == 0) {
+      scan_uuids_to_filter_count_.erase(it);
+      did_remove_service = true;
+    }
+  }
+  if (did_remove_service) {
+    pending_ = true;
+    TryStartDiscovery();

[Jeffrey Yasskin, 2016/08/23 21:37:04]

Shouldn't RemoveDiscoveryUUIDs stop discovery when no UUIDs are left?

+  }
+}
+
 void BluetoothLowEnergyDiscoveryManagerMac::StopDiscovery() {
   VLOG(1) << "StopDiscovery";
+  scan_uuids_to_filter_count_.clear();
   if (discovering_ && !pending_) {
     [central_manager_ stopScan];
   }
   discovering_ = false;
 }
 
 void BluetoothLowEnergyDiscoveryManagerMac::SetCentralManager(
     CBCentralManager* central_manager) {
   central_manager_ = central_manager;
 }
@@ skipping 12 matching lines @@
 }
 
 BluetoothLowEnergyDiscoveryManagerMac::BluetoothLowEnergyDiscoveryManagerMac(
     Observer* observer)
     : observer_(observer) {
   DCHECK(BluetoothAdapterMac::IsLowEnergyAvailable());
   discovering_ = false;
 }
 
 }  // namespace device