[CrOS PhoneHub] Update BleScanner to support multiple mediums

BleScanner scans for incoming BLE advertisements but only notifies
observers of results once they have been filtered by parameters provided
by clients. Before this CL, a filter consisted of a DeviceIdPair and a
ConnectionRole.

We will be utilizing BleScanner for Phone Hub, so now it must also
filter by ConnectionMedium. Since ConnectionAttemptDetails objects
consist of a DeviceIdPair, a ConnectionMedium, and a ConnectionRole
(i.e., exactly what we need), this CL change the type of the scan filter
parameters with ConnectionAttemptDetails.

A TODO is added in ble_scanner_impl.cc to reflect the fact that we must
now include the medium as part of the filtering process. This is left
for a follow-up CL.

Bug: 1106937
Change-Id: I251fe812b87145ae9861140af7021dfe2530084b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2392954
Commit-Queue: Kyle Horimoto <khorimoto@chromium.org>
Reviewed-by: James Vecore <vecore@google.com>
Cr-Commit-Position: refs/heads/master@{#805187}

chromeos/services/secure_channel/ble_connection_manager_impl.cc

@@ -237,8 +237,9 @@ void BleConnectionManagerImpl::PerformAttemptBleInitiatorConnection(
       device_id_pair.remote_device_id(), ConnectionRole::kInitiatorRole);
 
   ble_advertiser_->AddAdvertisementRequest(device_id_pair, connection_priority);
-  ble_scanner_->AddScanFilter(
-      BleScanner::ScanFilter(device_id_pair, ConnectionRole::kInitiatorRole));
+  ble_scanner_->AddScanRequest(ConnectionAttemptDetails(
+      device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+      ConnectionRole::kInitiatorRole));
 }
 
 void BleConnectionManagerImpl::PerformUpdateBleInitiatorConnectionPriority(
@@ -269,8 +270,9 @@ void BleConnectionManagerImpl::PerformCancelBleInitiatorConnectionAttempt(
     return;
 
   ble_advertiser_->RemoveAdvertisementRequest(device_id_pair);
-  ble_scanner_->RemoveScanFilter(
-      BleScanner::ScanFilter(device_id_pair, ConnectionRole::kInitiatorRole));
+  ble_scanner_->RemoveScanRequest(ConnectionAttemptDetails(
+      device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+      ConnectionRole::kInitiatorRole));
 }
 
 void BleConnectionManagerImpl::PerformAttemptBleListenerConnection(
@@ -282,8 +284,9 @@ void BleConnectionManagerImpl::PerformAttemptBleListenerConnection(
   StartConnectionAttemptTimerMetricsIfNecessary(
       device_id_pair.remote_device_id(), ConnectionRole::kListenerRole);
 
-  ble_scanner_->AddScanFilter(
-      BleScanner::ScanFilter(device_id_pair, ConnectionRole::kListenerRole));
+  ble_scanner_->AddScanRequest(ConnectionAttemptDetails(
+      device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+      ConnectionRole::kListenerRole));
 }
 
 void BleConnectionManagerImpl::PerformUpdateBleListenerConnectionPriority(
@@ -309,8 +312,9 @@ void BleConnectionManagerImpl::PerformCancelBleListenerConnectionAttempt(
   if (notifying_remote_device_id_ == device_id_pair.remote_device_id())
     return;
 
-  ble_scanner_->RemoveScanFilter(
-      BleScanner::ScanFilter(device_id_pair, ConnectionRole::kListenerRole));
+  ble_scanner_->RemoveScanRequest(ConnectionAttemptDetails(
+      device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+      ConnectionRole::kListenerRole));
 }
 
 void BleConnectionManagerImpl::OnAdvertisingSlotEnded(

chromeos/services/secure_channel/ble_connection_manager_impl_unittest.cc

@@ -420,13 +420,15 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
     if (expected_to_add_request) {
       EXPECT_EQ(connection_priority,
                 *fake_ble_advertiser()->GetPriorityForRequest(device_id_pair));
-      EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kInitiatorRole)));
+      EXPECT_TRUE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kInitiatorRole)));
     } else {
       EXPECT_FALSE(
           fake_ble_advertiser()->GetPriorityForRequest(device_id_pair));
-      EXPECT_FALSE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kInitiatorRole)));
+      EXPECT_FALSE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kInitiatorRole)));
     }
   }
 
@@ -443,13 +445,15 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
     if (expected_to_update_priority) {
       EXPECT_EQ(connection_priority,
                 *fake_ble_advertiser()->GetPriorityForRequest(device_id_pair));
-      EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kInitiatorRole)));
+      EXPECT_TRUE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kInitiatorRole)));
     } else {
       EXPECT_FALSE(
           fake_ble_advertiser()->GetPriorityForRequest(device_id_pair));
-      EXPECT_FALSE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kInitiatorRole)));
+      EXPECT_FALSE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kInitiatorRole)));
     }
   }
 
@@ -458,8 +462,9 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
                                           ConnectionRole::kInitiatorRole);
     manager_->CancelBleInitiatorConnectionAttempt(device_id_pair);
     EXPECT_FALSE(fake_ble_advertiser()->GetPriorityForRequest(device_id_pair));
-    EXPECT_FALSE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-        device_id_pair, ConnectionRole::kInitiatorRole)));
+    EXPECT_FALSE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+        device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+        ConnectionRole::kInitiatorRole)));
   }
 
   void AttemptBleListenerConnection(const DeviceIdPair& device_id_pair,
@@ -481,11 +486,13 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
             should_cancel_attempt_on_failure));
 
     if (expected_to_add_request) {
-      EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kListenerRole)));
+      EXPECT_TRUE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kListenerRole)));
     } else {
-      EXPECT_FALSE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kListenerRole)));
+      EXPECT_FALSE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kListenerRole)));
     }
   }
 
@@ -500,11 +507,13 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
                                                   connection_priority);
 
     if (expected_to_update_priority) {
-      EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kListenerRole)));
+      EXPECT_TRUE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kListenerRole)));
     } else {
-      EXPECT_FALSE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-          device_id_pair, ConnectionRole::kListenerRole)));
+      EXPECT_FALSE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+          device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+          ConnectionRole::kListenerRole)));
     }
   }
 
@@ -512,8 +521,9 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
     RemoveFromRemoteDeviceIdToMetadataMap(device_id_pair,
                                           ConnectionRole::kListenerRole);
     manager_->CancelBleListenerConnectionAttempt(device_id_pair);
-    EXPECT_FALSE(fake_ble_scanner()->HasScanFilter(
-        BleScanner::ScanFilter(device_id_pair, ConnectionRole::kListenerRole)));
+    EXPECT_FALSE(fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+        device_id_pair, ConnectionMedium::kBluetoothLowEnergy,
+        ConnectionRole::kListenerRole)));
   }
 
   void SimulateBleSlotEnding(const DeviceIdPair& device_id_pair,
@@ -562,7 +572,7 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
                     .empty());
     EXPECT_TRUE(
         fake_ble_scanner()
-            ->GetAllScanFiltersForRemoteDevice(remote_device.GetDeviceId())
+            ->GetAllScanRequestsForRemoteDevice(remote_device.GetDeviceId())
             .empty());
 
     FakeSecureChannelConnection* last_created_secure_channel =
@@ -637,14 +647,18 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
           EXPECT_EQ(std::get<2>(tuple),
                     *fake_ble_advertiser()->GetPriorityForRequest(
                         std::get<0>(tuple)));
-          EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-              std::get<0>(tuple), ConnectionRole::kInitiatorRole)));
+          EXPECT_TRUE(
+              fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+                  std::get<0>(tuple), ConnectionMedium::kBluetoothLowEnergy,
+                  ConnectionRole::kInitiatorRole)));
           break;
         }
 
         case ConnectionRole::kListenerRole: {
-          EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-              std::get<0>(tuple), ConnectionRole::kListenerRole)));
+          EXPECT_TRUE(
+              fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+                  std::get<0>(tuple), ConnectionMedium::kBluetoothLowEnergy,
+                  ConnectionRole::kListenerRole)));
           break;
         }
       }
@@ -680,14 +694,18 @@ class SecureChannelBleConnectionManagerImplTest : public testing::Test {
           EXPECT_EQ(std::get<2>(tuple),
                     *fake_ble_advertiser()->GetPriorityForRequest(
                         std::get<0>(tuple)));
-          EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-              std::get<0>(tuple), ConnectionRole::kInitiatorRole)));
+          EXPECT_TRUE(
+              fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+                  std::get<0>(tuple), ConnectionMedium::kBluetoothLowEnergy,
+                  ConnectionRole::kInitiatorRole)));
           break;
         }
 
         case ConnectionRole::kListenerRole: {
-          EXPECT_TRUE(fake_ble_scanner()->HasScanFilter(BleScanner::ScanFilter(
-              std::get<0>(tuple), ConnectionRole::kListenerRole)));
+          EXPECT_TRUE(
+              fake_ble_scanner()->HasScanRequest(ConnectionAttemptDetails(
+                  std::get<0>(tuple), ConnectionMedium::kBluetoothLowEnergy,
+                  ConnectionRole::kListenerRole)));
           break;
         }
       }

chromeos/services/secure_channel/ble_scanner.cc

@@ -17,30 +17,31 @@ BleScanner::BleScanner() = default;
 
 BleScanner::~BleScanner() = default;
 
-void BleScanner::AddScanFilter(const ScanFilter& scan_filter) {
-  if (base::Contains(scan_filters_, scan_filter)) {
-    PA_LOG(ERROR) << "BleScanner::AddScanFilter(): Tried to add a scan filter "
-                  << "which already existed. Filter: " << scan_filter;
+void BleScanner::AddScanRequest(const ConnectionAttemptDetails& scan_request) {
+  if (base::Contains(scan_requests_, scan_request)) {
+    PA_LOG(ERROR) << "BleScanner::AddScanRequest(): Tried to add a scan "
+                  << "request which already existed: " << scan_request;
     NOTREACHED();
   }
 
-  scan_filters_.insert(scan_filter);
-  HandleScanFilterChange();
+  scan_requests_.insert(scan_request);
+  HandleScanRequestChange();
 }
 
-void BleScanner::RemoveScanFilter(const ScanFilter& scan_filter) {
-  if (!base::Contains(scan_filters_, scan_filter)) {
-    PA_LOG(ERROR) << "BleScanner::RemoveScanFilter(): Tried to remove a scan "
-                  << "filter which was not present. Filter: " << scan_filter;
+void BleScanner::RemoveScanRequest(
+    const ConnectionAttemptDetails& scan_request) {
+  if (!base::Contains(scan_requests_, scan_request)) {
+    PA_LOG(ERROR) << "BleScanner::RemoveScanRequest(): Tried to remove a scan "
+                  << "request which was not present: " << scan_request;
     NOTREACHED();
   }
 
-  scan_filters_.erase(scan_filter);
-  HandleScanFilterChange();
+  scan_requests_.erase(scan_request);
+  HandleScanRequestChange();
 }
 
-bool BleScanner::HasScanFilter(const ScanFilter& scan_filter) {
-  return base::Contains(scan_filters_, scan_filter);
+bool BleScanner::HasScanRequest(const ConnectionAttemptDetails& scan_request) {
+  return base::Contains(scan_requests_, scan_request);
 }
 
 void BleScanner::AddObserver(Observer* observer) {
@@ -53,8 +54,8 @@ void BleScanner::RemoveObserver(Observer* observer) {
 
 DeviceIdPairSet BleScanner::GetAllDeviceIdPairs() {
   DeviceIdPairSet set;
-  for (const auto& scan_filter : scan_filters_)
-    set.insert(scan_filter.first);
+  for (const auto& scan_request : scan_requests_)
+    set.insert(scan_request.device_id_pair());
   return set;
 }
 
@@ -68,13 +69,6 @@ void BleScanner::NotifyReceivedAdvertisementFromDevice(
   }
 }
 
-std::ostream& operator<<(std::ostream& stream,
-                         const BleScanner::ScanFilter& scan_filter) {
-  stream << "{device_id_pair: " << scan_filter.first
-         << ", connection_role: " << scan_filter.second << "}";
-  return stream;
-}
-
 }  // namespace secure_channel
 
 }  // namespace chromeos

chromeos/services/secure_channel/ble_scanner.h

@@ -13,19 +13,21 @@
 #include "base/observer_list.h"
 #include "base/observer_list_types.h"
 #include "chromeos/components/multidevice/remote_device_ref.h"
+#include "chromeos/services/secure_channel/connection_attempt_details.h"
 #include "chromeos/services/secure_channel/connection_role.h"
 #include "chromeos/services/secure_channel/device_id_pair.h"
 
 namespace device {
 class BluetoothDevice;
-}
+}  // namespace device
 
 namespace chromeos {
 
 namespace secure_channel {
 
 // Performs BLE scans and notifies its delegate when an advertisement has been
-// received from a remote device.
+// received from a remote device. This class allows clients to specify what type
+// of connection they are scanning for and filters results accordingly.
 class BleScanner {
  public:
   class Observer : public base::CheckedObserver {
@@ -39,19 +41,17 @@ class BleScanner {
 
   virtual ~BleScanner();
 
-  using ScanFilter = std::pair<DeviceIdPair, ConnectionRole>;
+  // Adds a scan request for the provided ConnectionAttemptDetails. If no scan
+  // requests were previously present, adding a scan request will start a BLE
+  // discovery session.
+  void AddScanRequest(const ConnectionAttemptDetails& scan_request);
 
-  // Adds a scan filter for the provided ScanFilter. If no scan filters were
-  // previously present, adding a scan filter will start a BLE discovery session
-  // and attempt to create a connection.
-  void AddScanFilter(const ScanFilter& scan_filter);
+  // Removes a scan request for the provided ConnectionAttemptDetails. If this
+  // function removes the only remaining request, the ongoing BLE discovery
+  // session will stop.
+  void RemoveScanRequest(const ConnectionAttemptDetails& scan_request);
 
-  // Removes a scan filter for the provided ScanFilter. If this function
-  // removes the only remaining filter, the ongoing BLE discovery session will
-  // stop.
-  void RemoveScanFilter(const ScanFilter& scan_filter);
-
-  bool HasScanFilter(const ScanFilter& scan_filter);
+  bool HasScanRequest(const ConnectionAttemptDetails& scan_request);
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
@@ -59,10 +59,12 @@ class BleScanner {
  protected:
   BleScanner();
 
-  virtual void HandleScanFilterChange() = 0;
+  virtual void HandleScanRequestChange() = 0;
 
-  bool should_discovery_session_be_active() { return !scan_filters_.empty(); }
-  const base::flat_set<ScanFilter>& scan_filters() { return scan_filters_; }
+  bool should_discovery_session_be_active() { return !scan_requests_.empty(); }
+  const base::flat_set<ConnectionAttemptDetails>& scan_requests() {
+    return scan_requests_;
+  }
   DeviceIdPairSet GetAllDeviceIdPairs();
 
   void NotifyReceivedAdvertisementFromDevice(
@@ -73,14 +75,11 @@ class BleScanner {
  private:
   base::ObserverList<Observer> observer_list_;
 
-  base::flat_set<ScanFilter> scan_filters_;
+  base::flat_set<ConnectionAttemptDetails> scan_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(BleScanner);
 };
 
-std::ostream& operator<<(std::ostream& stream,
-                         const BleScanner::ScanFilter& scan_filter);
-
 }  // namespace secure_channel
 
 }  // namespace chromeos

chromeos/services/secure_channel/ble_scanner_impl.cc

@@ -77,7 +77,7 @@ BleScannerImpl::~BleScannerImpl() {
   adapter_->RemoveObserver(this);
 }
 
-void BleScannerImpl::HandleScanFilterChange() {
+void BleScannerImpl::HandleScanRequestChange() {
   UpdateDiscoveryStatus();
 }
 
@@ -206,7 +206,7 @@ void BleScannerImpl::HandleDeviceUpdated(
       service_data_str, GetAllDeviceIdPairs());
 
   // There was service data for the ProximityAuth UUID, but it did not apply to
-  // any active scan filters. The advertisement was likely from a nearby device
+  // any active scan requests. The advertisement was likely from a nearby device
   // attempting a ProximityAuth connection for another account.
   if (!potential_result)
     return;
@@ -225,18 +225,20 @@ void BleScannerImpl::HandlePotentialScanResult(
                                        ? ConnectionRole::kListenerRole
                                        : ConnectionRole::kInitiatorRole;
 
-  // Check to see if a corresponding scan filter exists. At this point, it is
+  // Check to see if a corresponding scan request exists. At this point, it is
   // possible that a scan result was received for the correct DeviceIdPair but
   // incorrect ConnectionRole.
-  bool does_corresponding_scan_filter_exist = false;
-  for (const auto& scan_filter : scan_filters()) {
-    if (scan_filter.first.remote_device_id() !=
+  bool does_corresponding_scan_request_exist = false;
+  for (const auto& scan_request : scan_requests()) {
+    if (scan_request.remote_device_id() !=
         potential_result.first.GetDeviceId()) {
       continue;
     }
 
-    if (scan_filter.second == connection_role) {
-      does_corresponding_scan_filter_exist = true;
+    // TODO(khorimoto): Also handle Nearby cases; currently, it is assumed that
+    // only BLE scan results are handled.
+    if (scan_request.connection_role() == connection_role) {
+      does_corresponding_scan_request_exist = true;
       break;
     }
   }
@@ -247,12 +249,12 @@ void BleScannerImpl::HandlePotentialScanResult(
   for (const auto& character : service_data)
     ss << static_cast<uint32_t>(character);
 
-  if (!does_corresponding_scan_filter_exist) {
+  if (!does_corresponding_scan_request_exist) {
     PA_LOG(WARNING) << "BleScannerImpl::HandleDeviceUpdated(): Received scan "
                     << "result from device with ID \""
                     << potential_result.first.GetTruncatedDeviceIdForLogs()
                     << "\", but it did not correspond to an active scan "
-                    << "filter. Service data: " << ss.str()
+                    << "request. Service data: " << ss.str()
                     << ", Background advertisement: "
                     << (potential_result.second ? "true" : "false");
     return;

chromeos/services/secure_channel/ble_scanner_impl.h

@@ -70,7 +70,7 @@ class BleScannerImpl : public BleScanner,
                  scoped_refptr<device::BluetoothAdapter> adapter);
 
   // BleScanner:
-  void HandleScanFilterChange() override;
+  void HandleScanRequestChange() override;
 
   // device::BluetoothAdapter::Observer:
   void DeviceAdvertisementReceived(device::BluetoothAdapter* adapter,

chromeos/services/secure_channel/ble_scanner_impl_unittest.cc

@@ -127,10 +127,10 @@ class SecureChannelBleScannerImplTest : public testing::Test {
     ble_scanner_->RemoveObserver(fake_delegate_.get());
   }
 
-  void AddScanFilter(const BleScanner::ScanFilter& scan_filter) {
-    EXPECT_FALSE(ble_scanner_->HasScanFilter(scan_filter));
-    ble_scanner_->AddScanFilter(scan_filter);
-    EXPECT_TRUE(ble_scanner_->HasScanFilter(scan_filter));
+  void AddScanRequest(const ConnectionAttemptDetails& scan_filter) {
+    EXPECT_FALSE(ble_scanner_->HasScanRequest(scan_filter));
+    ble_scanner_->AddScanRequest(scan_filter);
+    EXPECT_TRUE(ble_scanner_->HasScanRequest(scan_filter));
   }
 
   // StartDiscoverySession in the mock adapter mostly for the purpose of
@@ -146,10 +146,10 @@ class SecureChannelBleScannerImplTest : public testing::Test {
         base::RepeatingClosure());
   }
 
-  void RemoveScanFilter(const BleScanner::ScanFilter& scan_filter) {
-    EXPECT_TRUE(ble_scanner_->HasScanFilter(scan_filter));
-    ble_scanner_->RemoveScanFilter(scan_filter);
-    EXPECT_FALSE(ble_scanner_->HasScanFilter(scan_filter));
+  void RemoveScanRequest(const ConnectionAttemptDetails& scan_filter) {
+    EXPECT_TRUE(ble_scanner_->HasScanRequest(scan_filter));
+    ble_scanner_->RemoveScanRequest(scan_filter);
+    EXPECT_FALSE(ble_scanner_->HasScanRequest(scan_filter));
   }
 
   void ProcessScanResultAndVerifyNoDeviceIdentified(
@@ -263,27 +263,29 @@ class SecureChannelBleScannerImplTest : public testing::Test {
 };
 
 TEST_F(SecureChannelBleScannerImplTest, UnrelatedScanResults) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kListenerRole);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kListenerRole);
 
-  AddScanFilter(filter);
+  AddScanRequest(filter);
   InvokeStartDiscoveryCallback(true /* success */, 0u /* command_index */);
   EXPECT_TRUE(discovery_session_is_active());
 
   ProcessScanResultAndVerifyNoDeviceIdentified("unrelatedServiceData");
 
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
   InvokeStopDiscoveryCallback(true /* success */, 1u /* command_index */);
   EXPECT_FALSE(discovery_session_is_active());
 }
 
 TEST_F(SecureChannelBleScannerImplTest, IncorrectRole) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kListenerRole);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kListenerRole);
 
-  AddScanFilter(filter);
+  AddScanRequest(filter);
   InvokeStartDiscoveryCallback(true /* success */, 0u /* command_index */);
   EXPECT_TRUE(discovery_session_is_active());
 
@@ -295,55 +297,59 @@ TEST_F(SecureChannelBleScannerImplTest, IncorrectRole) {
 
   ProcessScanResultAndVerifyNoDeviceIdentified("wrongRoleServiceData");
 
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
   InvokeStopDiscoveryCallback(true /* success */, 1u /* command_index */);
   EXPECT_FALSE(discovery_session_is_active());
 }
 
 TEST_F(SecureChannelBleScannerImplTest, IdentifyDevice_Background) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kListenerRole);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kListenerRole);
 
-  AddScanFilter(filter);
+  AddScanRequest(filter);
   InvokeStartDiscoveryCallback(true /* success */, 0u /* command_index */);
   EXPECT_TRUE(discovery_session_is_active());
 
   ProcessScanResultAndVerifyDevice("device0ServiceData", test_devices()[0],
                                    true /* is_background_advertisement */);
 
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
   InvokeStopDiscoveryCallback(true /* success */, 1u /* command_index */);
   EXPECT_FALSE(discovery_session_is_active());
 }
 
 TEST_F(SecureChannelBleScannerImplTest, IdentifyDevice_Foreground) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kInitiatorRole);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kInitiatorRole);
 
-  AddScanFilter(filter);
+  AddScanRequest(filter);
   InvokeStartDiscoveryCallback(true /* success */, 0u /* command_index */);
   EXPECT_TRUE(discovery_session_is_active());
 
   ProcessScanResultAndVerifyDevice("device0ServiceData", test_devices()[0],
                                    false /* is_background_advertisement */);
 
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
   InvokeStopDiscoveryCallback(true /* success */, 1u /* command_index */);
   EXPECT_FALSE(discovery_session_is_active());
 }
 
 TEST_F(SecureChannelBleScannerImplTest, IdentifyDevice_MultipleScans) {
-  BleScanner::ScanFilter filter_1(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                               test_devices()[1].GetDeviceId()),
-                                  ConnectionRole::kInitiatorRole);
-  BleScanner::ScanFilter filter_2(DeviceIdPair(test_devices()[2].GetDeviceId(),
-                                               test_devices()[1].GetDeviceId()),
-                                  ConnectionRole::kInitiatorRole);
-
-  AddScanFilter(filter_1);
-  AddScanFilter(filter_2);
+  ConnectionAttemptDetails filter_1(
+      DeviceIdPair(test_devices()[0].GetDeviceId(),
+                   test_devices()[1].GetDeviceId()),
+      ConnectionMedium::kBluetoothLowEnergy, ConnectionRole::kInitiatorRole);
+  ConnectionAttemptDetails filter_2(
+      DeviceIdPair(test_devices()[2].GetDeviceId(),
+                   test_devices()[1].GetDeviceId()),
+      ConnectionMedium::kBluetoothLowEnergy, ConnectionRole::kInitiatorRole);
+
+  AddScanRequest(filter_1);
+  AddScanRequest(filter_2);
   InvokeStartDiscoveryCallback(true /* success */, 0u /* command_index */);
   EXPECT_TRUE(discovery_session_is_active());
 
@@ -352,7 +358,7 @@ TEST_F(SecureChannelBleScannerImplTest, IdentifyDevice_MultipleScans) {
                                    false /* is_background_advertisement */);
 
   // Remove the identified device from the list of scan filters.
-  RemoveScanFilter(filter_1);
+  RemoveScanRequest(filter_1);
 
   // No additional BLE command should have been posted, since the existing scan
   // should not have been stopped.
@@ -360,13 +366,13 @@ TEST_F(SecureChannelBleScannerImplTest, IdentifyDevice_MultipleScans) {
   EXPECT_TRUE(discovery_session_is_active());
 
   // Remove the scan filter, and verify that the scan stopped.
-  RemoveScanFilter(filter_2);
+  RemoveScanRequest(filter_2);
   InvokeStopDiscoveryCallback(true /* success */, 1u /* command_index */);
   EXPECT_FALSE(discovery_session_is_active());
 
   // Add the scan filter back again; this should start the discovery session
   // back up again.
-  AddScanFilter(filter_2);
+  AddScanRequest(filter_2);
   InvokeStartDiscoveryCallback(true /* success */, 2u /* command_index */);
   EXPECT_TRUE(discovery_session_is_active());
 
@@ -375,16 +381,17 @@ TEST_F(SecureChannelBleScannerImplTest, IdentifyDevice_MultipleScans) {
                                    false /* is_background_advertisement */);
 
   // Remove the scan filter, and verify that the scan stopped.
-  RemoveScanFilter(filter_2);
+  RemoveScanRequest(filter_2);
   InvokeStopDiscoveryCallback(true /* success */, 3u /* command_index */);
   EXPECT_FALSE(discovery_session_is_active());
 }
 
 TEST_F(SecureChannelBleScannerImplTest, StartAndStopFailures) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kListenerRole);
-  AddScanFilter(filter);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kListenerRole);
+  AddScanRequest(filter);
 
   // A request was made to start discovery; simulate this request failing.
   InvokeStartDiscoveryCallback(false /* success */, 0u /* command_index */);
@@ -400,7 +407,7 @@ TEST_F(SecureChannelBleScannerImplTest, StartAndStopFailures) {
 
   // Remove scan filters, which should trigger BleScanner to stop the
   // discovery session.
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
 
   // Simulate a failure to stop.
   InvokeStopDiscoveryCallback(false /* success */, 3u /* command_index */);
@@ -416,13 +423,14 @@ TEST_F(SecureChannelBleScannerImplTest, StartAndStopFailures) {
 }
 
 TEST_F(SecureChannelBleScannerImplTest, StartAndStop_EdgeCases) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kListenerRole);
-  AddScanFilter(filter);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kListenerRole);
+  AddScanRequest(filter);
 
   // Remove scan filters before the start discovery callback succeeds.
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
 
   // Complete starting the discovery session.
   InvokeStartDiscoveryCallback(true /* success */, 0u /* command_index */);
@@ -435,13 +443,14 @@ TEST_F(SecureChannelBleScannerImplTest, StartAndStop_EdgeCases) {
 }
 
 TEST_F(SecureChannelBleScannerImplTest, StartAndStopFailures_EdgeCases) {
-  BleScanner::ScanFilter filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
-                                             test_devices()[1].GetDeviceId()),
-                                ConnectionRole::kListenerRole);
-  AddScanFilter(filter);
+  ConnectionAttemptDetails filter(DeviceIdPair(test_devices()[0].GetDeviceId(),
+                                               test_devices()[1].GetDeviceId()),
+                                  ConnectionMedium::kBluetoothLowEnergy,
+                                  ConnectionRole::kListenerRole);
+  AddScanRequest(filter);
 
   // Remove scan filters before the start discovery callback succeeds.
-  RemoveScanFilter(filter);
+  RemoveScanRequest(filter);
 
   // Fail the pending call to start a discovery session.
   InvokeStartDiscoveryCallback(false /* success */, 0u /* command_index */);

chromeos/services/secure_channel/fake_ble_scanner.cc

@@ -12,19 +12,19 @@ FakeBleScanner::FakeBleScanner() = default;
 
 FakeBleScanner::~FakeBleScanner() = default;
 
-std::vector<BleScanner::ScanFilter>
-FakeBleScanner::GetAllScanFiltersForRemoteDevice(
+std::vector<ConnectionAttemptDetails>
+FakeBleScanner::GetAllScanRequestsForRemoteDevice(
     const std::string& remote_device_id) {
-  std::vector<ScanFilter> all_scan_filters_for_remote_device;
-  for (const auto& scan_filter : scan_filters()) {
-    if (scan_filter.first.remote_device_id() == remote_device_id)
-      all_scan_filters_for_remote_device.push_back(scan_filter);
+  std::vector<ConnectionAttemptDetails> all_scan_requests_for_remote_device;
+  for (const auto& scan_request : scan_requests()) {
+    if (scan_request.remote_device_id() == remote_device_id)
+      all_scan_requests_for_remote_device.push_back(scan_request);
   }
-  return all_scan_filters_for_remote_device;
+  return all_scan_requests_for_remote_device;
 }
 
-void FakeBleScanner::HandleScanFilterChange() {
-  ++num_scan_filter_changes_handled_;
+void FakeBleScanner::HandleScanRequestChange() {
+  ++num_scan_request_changes_handled_;
 }
 
 FakeBleScannerObserver::FakeBleScannerObserver() = default;

chromeos/services/secure_channel/fake_ble_scanner.h

@@ -22,21 +22,21 @@ class FakeBleScanner : public BleScanner {
   FakeBleScanner();
   ~FakeBleScanner() override;
 
-  size_t num_scan_filter_changes_handled() const {
-    return num_scan_filter_changes_handled_;
+  size_t num_scan_request_changes_handled() const {
+    return num_scan_request_changes_handled_;
   }
 
-  std::vector<ScanFilter> GetAllScanFiltersForRemoteDevice(
+  std::vector<ConnectionAttemptDetails> GetAllScanRequestsForRemoteDevice(
       const std::string& remote_device_id);
 
   // Public for testing.
-  using BleScanner::scan_filters;
   using BleScanner::NotifyReceivedAdvertisementFromDevice;
+  using BleScanner::scan_requests;
 
  private:
-  void HandleScanFilterChange() override;
+  void HandleScanRequestChange() override;
 
-  size_t num_scan_filter_changes_handled_ = 0u;
+  size_t num_scan_request_changes_handled_ = 0u;
 
   DISALLOW_COPY_AND_ASSIGN(FakeBleScanner);
 };