[CrOS Multidevice] Migrate BleScanner and BleAdvertiser to BleServiceDataHelper.

BLE advertisement logic like generating an advertisement and inspecting it
are factored into BleServiceDataHelper, allowing BleScanner and BleAdvertiser
to be agnostic of whether the new DeviceSync Mojo API is being used. This CL
completes Magic Tether's integration with the DeviceSync Mojo API; a user
can enable use of the API by enabling the kMultiDeviceApi flag.

This CL refactors BleAdvertisementGenerator and BackgroundEidGenerator to
accept RemoteDeviceRef lists with BeaconSeeds inside them, instead of
accepting a RemoteBeaconSeedFetcher. This removes the need for RemoteBeaconSeedFetcher;
it will be removed in a subsequent CL.

Bug: 824568, 752273
Change-Id: Ibfc8328ae979e176f438aa53b8258839133068b8
Reviewed-on: https://chromium-review.googlesource.com/1088311
Commit-Queue: Ryan Hansberry <hansberry@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565057}

chromeos/components/tether/asynchronous_shutdown_object_container_impl.cc

@@ -10,6 +10,7 @@
 #include "chromeos/components/tether/ble_connection_manager.h"
 #include "chromeos/components/tether/ble_connection_metrics_logger.h"
 #include "chromeos/components/tether/ble_scanner_impl.h"
+#include "chromeos/components/tether/ble_service_data_helper_impl.h"
 #include "chromeos/components/tether/disconnect_tethering_request_sender_impl.h"
 #include "chromeos/components/tether/network_configuration_remover.h"
 #include "chromeos/components/tether/wifi_hotspot_disconnector_impl.h"
@@ -91,21 +92,24 @@ AsynchronousShutdownObjectContainerImpl::
       remote_beacon_seed_fetcher_(
           std::make_unique<cryptauth::RemoteBeaconSeedFetcher>(
               cryptauth_service->GetCryptAuthDeviceManager())),
+      ble_service_data_helper_(
+          BleServiceDataHelperImpl::Factory::Get()->BuildInstance(
+              tether_host_fetcher_,
+              local_device_data_provider_.get(),
+              device_sync_client)),
       ble_advertisement_device_queue_(
           std::make_unique<BleAdvertisementDeviceQueue>()),
       ble_synchronizer_(
           secure_channel::BleSynchronizer::Factory::Get()->BuildInstance(
               adapter)),
       ble_advertiser_(BleAdvertiserImpl::Factory::NewInstance(
-          local_device_data_provider_.get(),
-          remote_beacon_seed_fetcher_.get(),
+          ble_service_data_helper_.get(),
           ble_synchronizer_.get())),
-      ble_scanner_(BleScannerImpl::Factory::NewInstance(
-          adapter,
-          local_device_data_provider_.get(),
-          remote_beacon_seed_fetcher_.get(),
-          ble_synchronizer_.get(),
-          tether_host_fetcher_)),
+      ble_scanner_(
+          BleScannerImpl::Factory::NewInstance(adapter,
+                                               ble_service_data_helper_.get(),
+                                               ble_synchronizer_.get(),
+                                               tether_host_fetcher_)),
       ble_connection_manager_(std::make_unique<BleConnectionManager>(
           adapter,
           ble_advertisement_device_queue_.get(),

chromeos/components/tether/asynchronous_shutdown_object_container_impl.h

@@ -41,6 +41,10 @@ namespace device_sync {
 class DeviceSyncClient;
 }  // namespace device_sync
 
+namespace secure_channel {
+class BleServiceDataHelper;
+}  // namespace secure_channel
+
 namespace tether {
 
 class BleAdvertisementDeviceQueue;
@@ -137,6 +141,8 @@ class AsynchronousShutdownObjectContainerImpl
       local_device_data_provider_;
   std::unique_ptr<cryptauth::RemoteBeaconSeedFetcher>
       remote_beacon_seed_fetcher_;
+  std::unique_ptr<secure_channel::BleServiceDataHelper>
+      ble_service_data_helper_;
   std::unique_ptr<BleAdvertisementDeviceQueue> ble_advertisement_device_queue_;
   std::unique_ptr<secure_channel::BleSynchronizerBase> ble_synchronizer_;
   std::unique_ptr<BleAdvertiser> ble_advertiser_;

chromeos/components/tether/asynchronous_shutdown_object_container_impl_unittest.cc

@@ -12,6 +12,7 @@
 #include "chromeos/components/tether/fake_ble_advertiser.h"
 #include "chromeos/components/tether/fake_ble_scanner.h"
 #include "chromeos/components/tether/fake_disconnect_tethering_request_sender.h"
+#include "chromeos/components/tether/fake_tether_host_fetcher.h"
 #include "chromeos/components/tether/tether_component_impl.h"
 #include "chromeos/services/device_sync/public/cpp/fake_device_sync_client.h"
 #include "components/cryptauth/fake_cryptauth_service.h"
@@ -74,6 +75,7 @@ class AsynchronousShutdownObjectContainerImplTest : public testing::Test {
         std::make_unique<cryptauth::FakeCryptAuthService>();
     fake_device_sync_client_ =
         std::make_unique<chromeos::device_sync::FakeDeviceSyncClient>();
+    fake_tether_host_fetcher_ = std::make_unique<FakeTetherHostFetcher>();
 
     test_pref_service_ =
         std::make_unique<sync_preferences::TestingPrefServiceSyncable>();
@@ -84,7 +86,8 @@ class AsynchronousShutdownObjectContainerImplTest : public testing::Test {
     // of objects created by the container.
     container_ = base::WrapUnique(new AsynchronousShutdownObjectContainerImpl(
         mock_adapter_, fake_cryptauth_service_.get(),
-        fake_device_sync_client_.get(), nullptr /* tether_host_fetcher */,
+        fake_device_sync_client_.get(),
+        fake_tether_host_fetcher_.get() /* tether_host_fetcher */,
         nullptr /* network_state_handler */,
         nullptr /* managed_network_configuration_handler */,
         nullptr /* network_connection_handler */,
@@ -120,6 +123,7 @@ class AsynchronousShutdownObjectContainerImplTest : public testing::Test {
   std::unique_ptr<cryptauth::FakeCryptAuthService> fake_cryptauth_service_;
   std::unique_ptr<chromeos::device_sync::FakeDeviceSyncClient>
       fake_device_sync_client_;
+  std::unique_ptr<FakeTetherHostFetcher> fake_tether_host_fetcher_;
   std::unique_ptr<sync_preferences::TestingPrefServiceSyncable>
       test_pref_service_;
   std::unique_ptr<FakeRemoteDeviceProviderFactory>

chromeos/components/tether/ble_advertiser_impl.cc

@@ -8,6 +8,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/secure_channel/ble_service_data_helper.h"
 #include "chromeos/services/secure_channel/device_id_pair.h"
 #include "chromeos/services/secure_channel/error_tolerant_ble_advertisement_impl.h"
 #include "components/cryptauth/ble/ble_advertisement_generator.h"
@@ -39,14 +40,13 @@ BleAdvertiserImpl::Factory* BleAdvertiserImpl::Factory::factory_instance_ =
 
 // static
 std::unique_ptr<BleAdvertiser> BleAdvertiserImpl::Factory::NewInstance(
-    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+    secure_channel::BleServiceDataHelper* ble_service_data_helper,
     secure_channel::BleSynchronizerBase* ble_synchronizer) {
   if (!factory_instance_)
     factory_instance_ = new Factory();
 
-  return factory_instance_->BuildInstance(
-      local_device_data_provider, remote_beacon_seed_fetcher, ble_synchronizer);
+  return factory_instance_->BuildInstance(ble_service_data_helper,
+                                          ble_synchronizer);
 }
 
 // static
@@ -55,12 +55,10 @@ void BleAdvertiserImpl::Factory::SetInstanceForTesting(Factory* factory) {
 }
 
 std::unique_ptr<BleAdvertiser> BleAdvertiserImpl::Factory::BuildInstance(
-    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+    secure_channel::BleServiceDataHelper* ble_service_data_helper,
     secure_channel::BleSynchronizerBase* ble_synchronizer) {
-  return base::WrapUnique(new BleAdvertiserImpl(local_device_data_provider,
-                                                remote_beacon_seed_fetcher,
-                                                ble_synchronizer));
+  return base::WrapUnique(
+      new BleAdvertiserImpl(ble_service_data_helper, ble_synchronizer));
 }
 
 BleAdvertiserImpl::AdvertisementMetadata::AdvertisementMetadata(
@@ -71,11 +69,9 @@ BleAdvertiserImpl::AdvertisementMetadata::AdvertisementMetadata(
 BleAdvertiserImpl::AdvertisementMetadata::~AdvertisementMetadata() = default;
 
 BleAdvertiserImpl::BleAdvertiserImpl(
-    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+    secure_channel::BleServiceDataHelper* ble_service_data_helper,
     secure_channel::BleSynchronizerBase* ble_synchronizer)
-    : remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher),
-      local_device_data_provider_(local_device_data_provider),
+    : ble_service_data_helper_(ble_service_data_helper),
       ble_synchronizer_(ble_synchronizer),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_ptr_factory_(this) {}
@@ -98,8 +94,9 @@ bool BleAdvertiserImpl::StartAdvertisingToDevice(const std::string& device_id) {
   }
 
   std::unique_ptr<cryptauth::DataWithTimestamp> service_data =
-      cryptauth::BleAdvertisementGenerator::GenerateBleAdvertisement(
-          device_id, local_device_data_provider_, remote_beacon_seed_fetcher_);
+      ble_service_data_helper_->GenerateForegroundAdvertisement(
+          secure_channel::DeviceIdPair(device_id /* remote_device_id */,
+                                       kStubLocalDeviceId));
   if (!service_data) {
     PA_LOG(WARNING) << "Error generating advertisement for device with ID "
                     << cryptauth::RemoteDeviceRef::TruncateDeviceIdForLogs(

chromeos/components/tether/ble_advertiser_impl.h

@@ -18,14 +18,10 @@ namespace base {
 class TaskRunner;
 }  // namespace base
 
-namespace cryptauth {
-class LocalDeviceDataProvider;
-class RemoteBeaconSeedFetcher;
-}  // namespace cryptauth
-
 namespace chromeos {
 
 namespace secure_channel {
+class BleServiceDataHelper;
 class BleSynchronizerBase;
 class ErrorTolerantBleAdvertisement;
 }  // namespace secure_channel
@@ -38,15 +34,13 @@ class BleAdvertiserImpl : public BleAdvertiser {
   class Factory {
    public:
     static std::unique_ptr<BleAdvertiser> NewInstance(
-        cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-        cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+        secure_channel::BleServiceDataHelper* ble_service_data_helper,
         secure_channel::BleSynchronizerBase* ble_synchronizer);
     static void SetInstanceForTesting(Factory* factory);
 
    protected:
     virtual std::unique_ptr<BleAdvertiser> BuildInstance(
-        cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-        cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+        secure_channel::BleServiceDataHelper* ble_service_data_helper,
         secure_channel::BleSynchronizerBase* ble_synchronizer);
 
    private:
@@ -62,8 +56,7 @@ class BleAdvertiserImpl : public BleAdvertiser {
 
  protected:
   BleAdvertiserImpl(
-      cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-      cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+      secure_channel::BleServiceDataHelper* ble_service_data_helper,
       secure_channel::BleSynchronizerBase* ble_synchronizer);
 
  private:
@@ -85,8 +78,7 @@ class BleAdvertiserImpl : public BleAdvertiser {
   void UpdateAdvertisements();
   void OnAdvertisementStopped(size_t index);
 
-  cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher_;
-  cryptauth::LocalDeviceDataProvider* local_device_data_provider_;
+  secure_channel::BleServiceDataHelper* ble_service_data_helper_;
   secure_channel::BleSynchronizerBase* ble_synchronizer_;
 
   scoped_refptr<base::TaskRunner> task_runner_;

chromeos/components/tether/ble_advertiser_impl_unittest.cc

@@ -13,13 +13,9 @@
 #include "chromeos/services/secure_channel/ble_constants.h"
 #include "chromeos/services/secure_channel/device_id_pair.h"
 #include "chromeos/services/secure_channel/error_tolerant_ble_advertisement_impl.h"
+#include "chromeos/services/secure_channel/fake_ble_service_data_helper.h"
 #include "chromeos/services/secure_channel/fake_ble_synchronizer.h"
 #include "chromeos/services/secure_channel/fake_error_tolerant_ble_advertisement.h"
-#include "components/cryptauth/ble/ble_advertisement_generator.h"
-#include "components/cryptauth/ble/fake_ble_advertisement_generator.h"
-#include "components/cryptauth/mock_foreground_eid_generator.h"
-#include "components/cryptauth/mock_local_device_data_provider.h"
-#include "components/cryptauth/mock_remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -30,6 +26,8 @@ namespace tether {
 
 namespace {
 
+const char kStubLocalDeviceId[] = "N/A";
+
 std::vector<cryptauth::DataWithTimestamp> GenerateFakeAdvertisements() {
   cryptauth::DataWithTimestamp advertisement1("advertisement1", 1000L, 2000L);
   cryptauth::DataWithTimestamp advertisement2("advertisement2", 2000L, 3000L);
@@ -131,15 +129,21 @@ class BleAdvertiserImplTest : public testing::Test {
         fake_advertisements_(GenerateFakeAdvertisements()) {}
 
   void SetUp() override {
-    fake_generator_ =
-        std::make_unique<cryptauth::FakeBleAdvertisementGenerator>();
-    cryptauth::BleAdvertisementGenerator::SetInstanceForTesting(
-        fake_generator_.get());
-
-    mock_seed_fetcher_ =
-        std::make_unique<cryptauth::MockRemoteBeaconSeedFetcher>();
-    mock_local_data_provider_ =
-        std::make_unique<cryptauth::MockLocalDeviceDataProvider>();
+    fake_ble_service_data_helper_ =
+        std::make_unique<secure_channel::FakeBleServiceDataHelper>();
+    fake_ble_service_data_helper_->SetAdvertisement(
+        secure_channel::DeviceIdPair(fake_devices_[0].GetDeviceId(),
+                                     kStubLocalDeviceId),
+        fake_advertisements_[0]);
+    fake_ble_service_data_helper_->SetAdvertisement(
+        secure_channel::DeviceIdPair(fake_devices_[1].GetDeviceId(),
+                                     kStubLocalDeviceId),
+        fake_advertisements_[1]);
+    fake_ble_service_data_helper_->SetAdvertisement(
+        secure_channel::DeviceIdPair(fake_devices_[2].GetDeviceId(),
+                                     kStubLocalDeviceId),
+        fake_advertisements_[2]);
+
     fake_ble_synchronizer_ =
         std::make_unique<secure_channel::FakeBleSynchronizer>();
 
@@ -149,8 +153,7 @@ class BleAdvertiserImplTest : public testing::Test {
         SetFactoryForTesting(fake_advertisement_factory_.get());
 
     ble_advertiser_ = base::WrapUnique(new BleAdvertiserImpl(
-        mock_local_data_provider_.get(), mock_seed_fetcher_.get(),
-        fake_ble_synchronizer_.get()));
+        fake_ble_service_data_helper_.get(), fake_ble_synchronizer_.get()));
 
     test_task_runner_ = base::MakeRefCounted<base::TestSimpleTaskRunner>();
     ble_advertiser_->SetTaskRunnerForTesting(test_task_runner_);
@@ -162,7 +165,6 @@ class BleAdvertiserImplTest : public testing::Test {
   void TearDown() override {
     secure_channel::ErrorTolerantBleAdvertisementImpl::Factory::
         SetFactoryForTesting(nullptr);
-    cryptauth::BleAdvertisementGenerator::SetInstanceForTesting(nullptr);
   }
 
   void VerifyAdvertisementHasBeenStopped(
@@ -189,13 +191,10 @@ class BleAdvertiserImplTest : public testing::Test {
   const cryptauth::RemoteDeviceRefList fake_devices_;
   const std::vector<cryptauth::DataWithTimestamp> fake_advertisements_;
 
-  std::unique_ptr<cryptauth::MockRemoteBeaconSeedFetcher> mock_seed_fetcher_;
-  std::unique_ptr<cryptauth::MockLocalDeviceDataProvider>
-      mock_local_data_provider_;
+  std::unique_ptr<secure_channel::FakeBleServiceDataHelper>
+      fake_ble_service_data_helper_;
   std::unique_ptr<secure_channel::FakeBleSynchronizer> fake_ble_synchronizer_;
 
-  std::unique_ptr<cryptauth::FakeBleAdvertisementGenerator> fake_generator_;
-
   scoped_refptr<base::TestSimpleTaskRunner> test_task_runner_;
 
   std::unique_ptr<TestObserver> test_observer_;
@@ -210,17 +209,18 @@ class BleAdvertiserImplTest : public testing::Test {
 };
 
 TEST_F(BleAdvertiserImplTest, CannotGenerateAdvertisement) {
-  fake_generator_->set_advertisement(nullptr);
+  fake_ble_service_data_helper_->RemoveAdvertisement(
+      secure_channel::DeviceIdPair(fake_devices_[0].GetDeviceId(),
+                                   kStubLocalDeviceId));
+
   EXPECT_FALSE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[0].GetDeviceId()));
   EXPECT_EQ(0u, fake_advertisement_factory_->num_created());
   EXPECT_EQ(0u, test_observer_->num_times_all_advertisements_unregistered());
 }
 
+// ryan
 TEST_F(BleAdvertiserImplTest, AdvertisementRegisteredSuccessfully) {
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
-
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[0].GetDeviceId()));
   EXPECT_EQ(1u, fake_advertisement_factory_->num_created());
@@ -249,9 +249,6 @@ TEST_F(BleAdvertiserImplTest, AdvertisementRegisteredSuccessfully) {
 }
 
 TEST_F(BleAdvertiserImplTest, AdvertisementRegisteredSuccessfully_TwoDevices) {
-  // Register device 0.
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[0].GetDeviceId()));
   EXPECT_EQ(1u, fake_advertisement_factory_->num_created());
@@ -259,9 +256,6 @@ TEST_F(BleAdvertiserImplTest, AdvertisementRegisteredSuccessfully_TwoDevices) {
   EXPECT_TRUE(ble_advertiser_->AreAdvertisementsRegistered());
   EXPECT_EQ(0u, test_observer_->num_times_all_advertisements_unregistered());
 
-  // Register device 1.
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[1]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[1].GetDeviceId()));
   EXPECT_EQ(2u, fake_advertisement_factory_->num_created());
@@ -295,24 +289,18 @@ TEST_F(BleAdvertiserImplTest, TooManyDevicesRegistered) {
   ASSERT_EQ(2u, secure_channel::kMaxConcurrentAdvertisements);
 
   // Register device 0.
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[0].GetDeviceId()));
   EXPECT_EQ(1u, fake_advertisement_factory_->num_created());
   EXPECT_EQ(1u, fake_advertisement_factory_->active_advertisements().size());
 
   // Register device 1.
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[1]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[1].GetDeviceId()));
   EXPECT_EQ(2u, fake_advertisement_factory_->num_created());
   EXPECT_EQ(2u, fake_advertisement_factory_->active_advertisements().size());
 
   // Register device 2. This should fail, since it is over the limit.
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[2]));
   EXPECT_FALSE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[2].GetDeviceId()));
   EXPECT_EQ(2u, fake_advertisement_factory_->num_created());
@@ -364,9 +352,6 @@ TEST_F(BleAdvertiserImplTest, TooManyDevicesRegistered) {
 // that the new advertisement in step (3) above does not start until the
 // previous one has been finished.
 TEST_F(BleAdvertiserImplTest, SameAdvertisementAdded_FirstHasNotBeenStopped) {
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
-
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[0].GetDeviceId()));
   EXPECT_EQ(1u, fake_advertisement_factory_->num_created());
@@ -381,8 +366,6 @@ TEST_F(BleAdvertiserImplTest, SameAdvertisementAdded_FirstHasNotBeenStopped) {
   // Start advertising again, to the same device. Since the previous
   // advertisement has not successfully stopped, no new advertisement should
   // have been created yet.
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(
       fake_devices_[0].GetDeviceId()));
   EXPECT_EQ(1u, fake_advertisement_factory_->num_created());
@@ -408,8 +391,6 @@ TEST_F(BleAdvertiserImplTest, ObserverDeletesObjectWhenNotified) {
   DeletingObserver deleting_observer(ble_advertiser_);
   ble_advertiser_->RemoveObserver(test_observer_.get());
 
-  fake_generator_->set_advertisement(
-      std::make_unique<cryptauth::DataWithTimestamp>(fake_advertisements_[0]));
   ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0].GetDeviceId());
   ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0].GetDeviceId());
   InvokeAdvertisementStoppedCallback(0u /* index */,

chromeos/components/tether/ble_scanner_impl.cc

@@ -14,10 +14,10 @@
 #include "chromeos/components/proximity_auth/logging/logging.h"
 #include "chromeos/components/tether/tether_host_fetcher.h"
 #include "chromeos/services/secure_channel/ble_constants.h"
+#include "chromeos/services/secure_channel/ble_service_data_helper.h"
 #include "chromeos/services/secure_channel/ble_synchronizer.h"
-#include "components/cryptauth/local_device_data_provider.h"
+#include "chromeos/services/secure_channel/device_id_pair.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
-#include "components/cryptauth/remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/remote_device_ref.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
@@ -29,6 +29,11 @@ namespace tether {
 
 namespace {
 
+// Instant Tethering does not make use of the "local device ID" argument, since
+// all connections are from the same device.
+// TODO(hansberry): Remove when SecureChannelClient migration is complete.
+const char kStubLocalDeviceId[] = "N/A";
+
 // Valid advertisement service data must be at least 2 bytes.
 // As of March 2018, valid background advertisement service data is exactly 2
 // bytes, which identify the advertising device to the scanning device.
@@ -36,8 +41,6 @@ namespace {
 // 2 bytes associated with the scanning device (used as a scan filter) and 2
 // bytes which identify the advertising device to the scanning device.
 const size_t kMinNumBytesInServiceData = 2;
-const size_t kMaxNumBytesInBackgroundServiceData = 3;
-const size_t kMinNumBytesInForegroundServiceData = 4;
 
 }  // namespace
 
@@ -47,16 +50,14 @@ BleScannerImpl::Factory* BleScannerImpl::Factory::factory_instance_ = nullptr;
 // static
 std::unique_ptr<BleScanner> BleScannerImpl::Factory::NewInstance(
     scoped_refptr<device::BluetoothAdapter> adapter,
-    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+    secure_channel::BleServiceDataHelper* ble_service_data_helper,
     secure_channel::BleSynchronizerBase* ble_synchronizer,
     TetherHostFetcher* tether_host_fetcher) {
   if (!factory_instance_)
     factory_instance_ = new Factory();
 
   return factory_instance_->BuildInstance(
-      adapter, local_device_data_provider, remote_beacon_seed_fetcher,
-      ble_synchronizer, tether_host_fetcher);
+      adapter, ble_service_data_helper, ble_synchronizer, tether_host_fetcher);
 }
 
 // static
@@ -66,13 +67,11 @@ void BleScannerImpl::Factory::SetInstanceForTesting(Factory* factory) {
 
 std::unique_ptr<BleScanner> BleScannerImpl::Factory::BuildInstance(
     scoped_refptr<device::BluetoothAdapter> adapter,
-    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+    secure_channel::BleServiceDataHelper* ble_service_data_helper,
     secure_channel::BleSynchronizerBase* ble_synchronizer,
     TetherHostFetcher* tether_host_fetcher) {
   return base::WrapUnique(new BleScannerImpl(
-      adapter, local_device_data_provider, remote_beacon_seed_fetcher,
-      ble_synchronizer, tether_host_fetcher));
+      adapter, ble_service_data_helper, ble_synchronizer, tether_host_fetcher));
 }
 
 BleScannerImpl::ServiceDataProviderImpl::ServiceDataProviderImpl() = default;
@@ -88,20 +87,14 @@ BleScannerImpl::ServiceDataProviderImpl::GetServiceDataForUUID(
 
 BleScannerImpl::BleScannerImpl(
     scoped_refptr<device::BluetoothAdapter> adapter,
-    cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+    secure_channel::BleServiceDataHelper* ble_service_data_helper,
     secure_channel::BleSynchronizerBase* ble_synchronizer,
     TetherHostFetcher* tether_host_fetcher)
     : adapter_(adapter),
-      local_device_data_provider_(local_device_data_provider),
-      remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher),
+      ble_service_data_helper_(ble_service_data_helper),
       ble_synchronizer_(ble_synchronizer),
       tether_host_fetcher_(tether_host_fetcher),
       service_data_provider_(std::make_unique<ServiceDataProviderImpl>()),
-      background_eid_generator_(
-          std::make_unique<cryptauth::BackgroundEidGenerator>()),
-      foreground_eid_generator_(
-          std::make_unique<cryptauth::ForegroundEidGenerator>()),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       weak_ptr_factory_(this) {
   adapter_->AddObserver(this);
@@ -123,22 +116,6 @@ bool BleScannerImpl::RegisterScanFilterForDevice(const std::string& device_id) {
     return false;
   }
 
-  std::vector<cryptauth::BeaconSeed> local_device_beacon_seeds;
-  if (!local_device_data_provider_->GetLocalDeviceData(
-          nullptr, &local_device_beacon_seeds)) {
-    PA_LOG(WARNING) << "Error fetching the local device's beacon seeds. Cannot "
-                    << "generate scan without beacon seeds.";
-    return false;
-  }
-
-  std::unique_ptr<cryptauth::ForegroundEidGenerator::EidData> scan_filters =
-      foreground_eid_generator_->GenerateBackgroundScanFilter(
-          local_device_beacon_seeds);
-  if (!scan_filters) {
-    PA_LOG(WARNING) << "Error generating background scan filters. Cannot scan";
-    return false;
-  }
-
   registered_remote_device_ids_.push_back(device_id);
   UpdateDiscoveryStatus();
 
@@ -177,12 +154,8 @@ bool BleScannerImpl::IsDiscoverySessionActive() {
 
 void BleScannerImpl::SetTestDoubles(
     std::unique_ptr<ServiceDataProvider> service_data_provider,
-    std::unique_ptr<cryptauth::BackgroundEidGenerator> background_eid_generator,
-    std::unique_ptr<cryptauth::ForegroundEidGenerator> foreground_eid_generator,
     scoped_refptr<base::TaskRunner> test_task_runner) {
   service_data_provider_ = std::move(service_data_provider);
-  background_eid_generator_ = std::move(background_eid_generator);
-  foreground_eid_generator_ = std::move(foreground_eid_generator);
   task_runner_ = test_task_runner;
 }
 
@@ -325,57 +298,23 @@ void BleScannerImpl::HandleDeviceUpdated(
 void BleScannerImpl::CheckForMatchingScanFilters(
     device::BluetoothDevice* bluetooth_device,
     const std::string& service_data) {
-  std::string device_id;
-  bool is_background_advertisement = false;
-
-  // First try, identifying |service_data| as a foreground advertisement.
-  if (service_data.size() >= kMinNumBytesInForegroundServiceData) {
-    std::vector<cryptauth::BeaconSeed> beacon_seeds;
-    if (local_device_data_provider_->GetLocalDeviceData(nullptr,
-                                                        &beacon_seeds)) {
-      device_id =
-          foreground_eid_generator_->IdentifyRemoteDeviceByAdvertisement(
-              service_data, registered_remote_device_ids_, beacon_seeds);
-    }
-  }
+  secure_channel::DeviceIdPairSet device_id_pair_set;
+  for (const auto& remote_device_id : registered_remote_device_ids_)
+    device_id_pair_set.emplace(remote_device_id, kStubLocalDeviceId);
 
-  // If the device has not yet been identified, try identifying |service_data|
-  // as a background advertisement.
-  if (chromeos::switches::IsInstantTetheringBackgroundAdvertisingSupported() &&
-      device_id.empty() && service_data.size() >= kMinNumBytesInServiceData &&
-      service_data.size() <= kMaxNumBytesInBackgroundServiceData) {
-    device_id = background_eid_generator_->IdentifyRemoteDeviceByAdvertisement(
-        remote_beacon_seed_fetcher_, service_data,
-        registered_remote_device_ids_);
-    is_background_advertisement = true;
-  }
+  base::Optional<secure_channel::BleServiceDataHelper::DeviceWithBackgroundBool>
+      device_with_background_bool =
+          ble_service_data_helper_->IdentifyRemoteDevice(service_data,
+                                                         device_id_pair_set);
 
   // If the service data does not correspond to an advertisement from a device
   // on this account, ignore it.
-  if (device_id.empty())
-    return;
-
-  tether_host_fetcher_->FetchTetherHost(
-      device_id, base::Bind(&BleScannerImpl::OnIdentifiedHostFetched,
-                            weak_ptr_factory_.GetWeakPtr(), bluetooth_device,
-                            device_id, is_background_advertisement));
-}
-
-void BleScannerImpl::OnIdentifiedHostFetched(
-    device::BluetoothDevice* bluetooth_device,
-    const std::string& device_id,
-    bool is_background_advertisement,
-    base::Optional<cryptauth::RemoteDeviceRef> identified_device) {
-  if (!identified_device) {
-    PA_LOG(ERROR) << "Unable to fetch RemoteDevice object with ID \""
-                  << cryptauth::RemoteDeviceRef::TruncateDeviceIdForLogs(
-                         device_id)
-                  << "\".";
+  if (!device_with_background_bool)
     return;
-  }
 
-  NotifyReceivedAdvertisementFromDevice(*identified_device, bluetooth_device,
-                                        is_background_advertisement);
+  NotifyReceivedAdvertisementFromDevice(
+      device_with_background_bool->first /* remote_device */, bluetooth_device,
+      device_with_background_bool->second /* is_background_advertisement */);
 }
 
 void BleScannerImpl::ScheduleStatusChangeNotification(

chromeos/components/tether/ble_scanner_impl.h

@@ -12,8 +12,6 @@
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
 #include "chromeos/components/tether/ble_scanner.h"
-#include "components/cryptauth/background_eid_generator.h"
-#include "components/cryptauth/foreground_eid_generator.h"
 #include "components/cryptauth/remote_device_ref.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 
@@ -21,11 +19,6 @@ namespace base {
 class TaskRunner;
 }  // namespace base
 
-namespace cryptauth {
-class LocalDeviceDataProvider;
-class RemoteBeaconSeedFetcher;
-}  // namespace cryptauth
-
 namespace device {
 class BluetoothDevice;
 class BluetoothDiscoverySession;
@@ -34,6 +27,7 @@ class BluetoothDiscoverySession;
 namespace chromeos {
 
 namespace secure_channel {
+class BleServiceDataHelper;
 class BleSynchronizerBase;
 }  // namespace secure_channel
 
@@ -49,8 +43,7 @@ class BleScannerImpl : public BleScanner,
    public:
     static std::unique_ptr<BleScanner> NewInstance(
         scoped_refptr<device::BluetoothAdapter> adapter,
-        cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-        cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+        secure_channel::BleServiceDataHelper* ble_service_data_helper,
         secure_channel::BleSynchronizerBase* ble_synchronizer,
         TetherHostFetcher* tether_host_fetcher);
 
@@ -59,8 +52,7 @@ class BleScannerImpl : public BleScanner,
    protected:
     virtual std::unique_ptr<BleScanner> BuildInstance(
         scoped_refptr<device::BluetoothAdapter> adapter,
-        cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-        cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+        secure_channel::BleServiceDataHelper* ble_service_data_helper,
         secure_channel::BleSynchronizerBase* ble_synchronizer,
         TetherHostFetcher* tether_host_fetcher);
 
@@ -77,8 +69,7 @@ class BleScannerImpl : public BleScanner,
 
  protected:
   BleScannerImpl(scoped_refptr<device::BluetoothAdapter> adapter,
-                 cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-                 cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
+                 secure_channel::BleServiceDataHelper* ble_service_data_helper,
                  secure_channel::BleSynchronizerBase* ble_synchronizer,
                  TetherHostFetcher* tether_host_fetcher);
 
@@ -108,10 +99,6 @@ class BleScannerImpl : public BleScanner,
 
   void SetTestDoubles(
       std::unique_ptr<ServiceDataProvider> service_data_provider,
-      std::unique_ptr<cryptauth::BackgroundEidGenerator>
-          background_eid_generator,
-      std::unique_ptr<cryptauth::ForegroundEidGenerator>
-          foreground_eid_generator,
       scoped_refptr<base::TaskRunner> test_task_runner);
 
   bool IsDeviceRegistered(const std::string& device_id);
@@ -136,23 +123,15 @@ class BleScannerImpl : public BleScanner,
   void HandleDeviceUpdated(device::BluetoothDevice* bluetooth_device);
   void CheckForMatchingScanFilters(device::BluetoothDevice* bluetooth_device,
                                    const std::string& service_data);
-  void OnIdentifiedHostFetched(
-      device::BluetoothDevice* bluetooth_device,
-      const std::string& device_id,
-      bool is_background_advertisement,
-      base::Optional<cryptauth::RemoteDeviceRef> identified_device);
 
   void ScheduleStatusChangeNotification(bool discovery_session_active);
 
   scoped_refptr<device::BluetoothAdapter> adapter_;
-  cryptauth::LocalDeviceDataProvider* local_device_data_provider_;
-  cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher_;
+  secure_channel::BleServiceDataHelper* ble_service_data_helper_;
   secure_channel::BleSynchronizerBase* ble_synchronizer_;
   TetherHostFetcher* tether_host_fetcher_;
 
   std::unique_ptr<ServiceDataProvider> service_data_provider_;
-  std::unique_ptr<cryptauth::BackgroundEidGenerator> background_eid_generator_;
-  std::unique_ptr<cryptauth::ForegroundEidGenerator> foreground_eid_generator_;
 
   std::vector<std::string> registered_remote_device_ids_;
 

chromeos/components/tether/ble_service_data_helper_impl.cc

@@ -9,12 +9,16 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/no_destructor.h"
+#include "chromeos/chromeos_features.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/components/proximity_auth/logging/logging.h"
+#include "chromeos/services/device_sync/public/cpp/device_sync_client.h"
+#include "chromeos/services/secure_channel/ble_constants.h"
 #include "components/cryptauth/background_eid_generator.h"
 #include "components/cryptauth/ble/ble_advertisement_generator.h"
 #include "components/cryptauth/foreground_eid_generator.h"
 #include "components/cryptauth/local_device_data_provider.h"
-#include "components/cryptauth/remote_beacon_seed_fetcher.h"
+#include "device/bluetooth/bluetooth_device.h"
 
 namespace chromeos {
 
@@ -59,19 +63,18 @@ std::unique_ptr<secure_channel::BleServiceDataHelper>
 BleServiceDataHelperImpl::Factory::BuildInstance(
     TetherHostFetcher* tether_host_fetcher,
     cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) {
+    device_sync::DeviceSyncClient* device_sync_client) {
   return base::WrapUnique(new BleServiceDataHelperImpl(
-      tether_host_fetcher, local_device_data_provider,
-      remote_beacon_seed_fetcher));
+      tether_host_fetcher, local_device_data_provider, device_sync_client));
 }
 
 BleServiceDataHelperImpl::BleServiceDataHelperImpl(
     TetherHostFetcher* tether_host_fetcher,
     cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher)
+    device_sync::DeviceSyncClient* device_sync_client)
     : tether_host_fetcher_(tether_host_fetcher),
       local_device_data_provider_(local_device_data_provider),
-      remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher),
+      device_sync_client_(device_sync_client),
       background_eid_generator_(
           std::make_unique<cryptauth::BackgroundEidGenerator>()),
       foreground_eid_generator_(
@@ -85,12 +88,57 @@ BleServiceDataHelperImpl::~BleServiceDataHelperImpl() {
   tether_host_fetcher_->RemoveObserver(this);
 }
 
+base::Optional<secure_channel::BleServiceDataHelper::DeviceWithBackgroundBool>
+BleServiceDataHelperImpl::IdentifyRemoteDevice(
+    const std::string& service_data,
+    const std::vector<std::string>& remote_device_ids) {
+  base::Optional<std::string> local_device_public_key =
+      GetLocalDevicePublicKey();
+  if (!local_device_public_key)
+    return base::nullopt;
+
+  // BleServiceDataHelper::IdentifyRemoteDevice() verifies that the devices its
+  // subclasses return are actually in |device_id_pair_set|. However, clients of
+  // BleServiceDataHelperImpl don't have easy access to local device metadata;
+  // therefore, pass along that required data here.
+  secure_channel::DeviceIdPairSet device_id_pair_set;
+  for (const auto& remote_device_id : remote_device_ids) {
+    device_id_pair_set.insert(secure_channel::DeviceIdPair(
+        remote_device_id, cryptauth::RemoteDeviceRef::GenerateDeviceId(
+                              *local_device_public_key)));
+  }
+
+  return secure_channel::BleServiceDataHelper::IdentifyRemoteDevice(
+      service_data, device_id_pair_set);
+}
+
 std::unique_ptr<cryptauth::DataWithTimestamp>
 BleServiceDataHelperImpl::GenerateForegroundAdvertisement(
     const secure_channel::DeviceIdPair& device_id_pair) {
+  base::Optional<std::string> local_device_public_key =
+      GetLocalDevicePublicKey();
+  if (!local_device_public_key) {
+    PA_LOG(ERROR) << "Local device public key is invalid.";
+    return nullptr;
+  }
+
+  base::Optional<cryptauth::RemoteDeviceRef> remote_device;
+  const auto remote_device_it = std::find_if(
+      tether_hosts_from_last_fetch_.begin(),
+      tether_hosts_from_last_fetch_.end(),
+      [&device_id_pair](auto remote_device) {
+        return device_id_pair.remote_device_id() == remote_device.GetDeviceId();
+      });
+
+  if (remote_device_it == tether_hosts_from_last_fetch_.end()) {
+    PA_LOG(WARNING) << "Requested remote device ID is not a valid host: "
+                    << cryptauth::RemoteDeviceRef::TruncateDeviceIdForLogs(
+                           device_id_pair.remote_device_id());
+    return nullptr;
+  }
+
   return cryptauth::BleAdvertisementGenerator::GenerateBleAdvertisement(
-      device_id_pair.remote_device_id(), local_device_data_provider_,
-      remote_beacon_seed_fetcher_);
+      *remote_device_it, *local_device_public_key);
 }
 
 base::Optional<secure_channel::BleServiceDataHelper::DeviceWithBackgroundBool>
@@ -103,12 +151,17 @@ BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
   // First try, identifying |service_data| as a foreground advertisement.
   if (service_data.size() >= kMinNumBytesInForegroundServiceData) {
     std::vector<cryptauth::BeaconSeed> beacon_seeds;
-    if (local_device_data_provider_->GetLocalDeviceData(nullptr,
-                                                        &beacon_seeds)) {
-      device_id =
-          foreground_eid_generator_->IdentifyRemoteDeviceByAdvertisement(
-              service_data, registered_remote_device_ids_, beacon_seeds);
+    if (base::FeatureList::IsEnabled(chromeos::features::kMultiDeviceApi)) {
+      beacon_seeds =
+          device_sync_client_->GetLocalDeviceMetadata()->beacon_seeds();
+    } else if (!local_device_data_provider_->GetLocalDeviceData(
+                   nullptr, &beacon_seeds)) {
+      PA_LOG(ERROR) << "Cannot fetch local beacon seeds.";
+      return base::nullopt;
     }
+
+    device_id = foreground_eid_generator_->IdentifyRemoteDeviceByAdvertisement(
+        service_data, registered_remote_device_ids_, beacon_seeds);
   }
 
   // If the device has not yet been identified, try identifying |service_data|
@@ -117,8 +170,7 @@ BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
       device_id.empty() && service_data.size() >= kMinNumBytesInServiceData &&
       service_data.size() <= kMaxNumBytesInBackgroundServiceData) {
     device_id = background_eid_generator_->IdentifyRemoteDeviceByAdvertisement(
-        remote_beacon_seed_fetcher_, service_data,
-        registered_remote_device_ids_);
+        service_data, tether_hosts_from_last_fetch_);
     is_background_advertisement = true;
   }
 
@@ -134,6 +186,9 @@ BleServiceDataHelperImpl::PerformIdentifyRemoteDevice(
     }
   }
 
+  PA_LOG(ERROR) << "Identified remote device ID is not a valid host: "
+                << cryptauth::RemoteDeviceRef::TruncateDeviceIdForLogs(
+                       device_id);
   NOTREACHED();
   return base::nullopt;
 }
@@ -155,6 +210,33 @@ void BleServiceDataHelperImpl::OnTetherHostsFetched(
                  [](const auto& host) { return host.GetDeviceId(); });
 }
 
+base::Optional<std::string>
+BleServiceDataHelperImpl::GetLocalDevicePublicKey() {
+  std::string local_device_public_key;
+  if (base::FeatureList::IsEnabled(chromeos::features::kMultiDeviceApi)) {
+    if (!device_sync_client_->GetLocalDeviceMetadata())
+      return base::nullopt;
+    local_device_public_key =
+        device_sync_client_->GetLocalDeviceMetadata()->public_key();
+  } else if (!local_device_data_provider_->GetLocalDeviceData(
+                 &local_device_public_key, nullptr)) {
+    return base::nullopt;
+  }
+
+  if (local_device_public_key.empty())
+    return base::nullopt;
+
+  return local_device_public_key;
+}
+
+void BleServiceDataHelperImpl::SetTestDoubles(
+    std::unique_ptr<cryptauth::BackgroundEidGenerator> background_eid_generator,
+    std::unique_ptr<cryptauth::ForegroundEidGenerator>
+        foreground_eid_generator) {
+  background_eid_generator_ = std::move(background_eid_generator);
+  foreground_eid_generator_ = std::move(foreground_eid_generator);
+}
+
 }  // namespace tether
 
 }  // namespace chromeos

chromeos/components/tether/ble_service_data_helper_impl.h

@@ -22,11 +22,14 @@ namespace cryptauth {
 class BackgroundEidGenerator;
 class ForegroundEidGenerator;
 class LocalDeviceDataProvider;
-class RemoteBeaconSeedFetcher;
 }  // namespace cryptauth
 
 namespace chromeos {
 
+namespace device_sync {
+class DeviceSyncClient;
+}  // namespace device_sync
+
 namespace tether {
 
 // chromeos::tether BleServiceDataHelper implementation.
@@ -41,7 +44,7 @@ class BleServiceDataHelperImpl : public secure_channel::BleServiceDataHelper,
     virtual std::unique_ptr<secure_channel::BleServiceDataHelper> BuildInstance(
         TetherHostFetcher* tether_host_fetcher,
         cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-        cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher);
+        device_sync::DeviceSyncClient* device_sync_client);
 
    private:
     static Factory* test_factory_;
@@ -49,11 +52,17 @@ class BleServiceDataHelperImpl : public secure_channel::BleServiceDataHelper,
 
   ~BleServiceDataHelperImpl() override;
 
+  base::Optional<DeviceWithBackgroundBool> IdentifyRemoteDevice(
+      const std::string& service_data,
+      const std::vector<std::string>& remote_device_ids);
+
  private:
+  friend class BleServiceDataHelperImplTest;
+
   BleServiceDataHelperImpl(
       TetherHostFetcher* tether_host_fetcher,
       cryptauth::LocalDeviceDataProvider* local_device_data_provider,
-      cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher);
+      device_sync::DeviceSyncClient* device_sync_client);
 
   // secure_channel::BleServiceDataHelper:
   std::unique_ptr<cryptauth::DataWithTimestamp> GenerateForegroundAdvertisement(
@@ -67,9 +76,16 @@ class BleServiceDataHelperImpl : public secure_channel::BleServiceDataHelper,
 
   void OnTetherHostsFetched(const cryptauth::RemoteDeviceRefList& tether_hosts);
 
+  base::Optional<std::string> GetLocalDevicePublicKey();
+
+  void SetTestDoubles(std::unique_ptr<cryptauth::BackgroundEidGenerator>
+                          background_eid_generator,
+                      std::unique_ptr<cryptauth::ForegroundEidGenerator>
+                          foreground_eid_generator);
+
   TetherHostFetcher* tether_host_fetcher_;
   cryptauth::LocalDeviceDataProvider* local_device_data_provider_;
-  cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher_;
+  device_sync::DeviceSyncClient* device_sync_client_;
 
   std::unique_ptr<cryptauth::BackgroundEidGenerator> background_eid_generator_;
   std::unique_ptr<cryptauth::ForegroundEidGenerator> foreground_eid_generator_;

chromeos/services/device_sync/public/cpp/fake_device_sync_client.h

@@ -47,7 +47,7 @@ class FakeDeviceSyncClient : public DeviceSyncClient {
     synced_devices_ = synced_devices;
   }
 
-  void setlocal_device_metadata(
+  void set_local_device_metadata(
       base::Optional<cryptauth::RemoteDeviceRef> local_device_metadata) {
     local_device_metadata_ = local_device_metadata;
   }

chromeos/services/secure_channel/fake_ble_service_data_helper.cc

@@ -20,6 +20,11 @@ void FakeBleServiceDataHelper::SetAdvertisement(
   device_id_pair_to_service_data_map_.insert({device_id_pair, service_data});
 }
 
+void FakeBleServiceDataHelper::RemoveAdvertisement(
+    const DeviceIdPair& device_id_pair) {
+  device_id_pair_to_service_data_map_.erase(device_id_pair);
+}
+
 void FakeBleServiceDataHelper::SetIdentifiedDevice(
     const std::string& service_data,
     cryptauth::RemoteDeviceRef identified_device,

chromeos/services/secure_channel/fake_ble_service_data_helper.h

@@ -30,6 +30,8 @@ class FakeBleServiceDataHelper : public BleServiceDataHelper {
   void SetAdvertisement(const DeviceIdPair& device_id_pair,
                         const cryptauth::DataWithTimestamp& service_data);
 
+  void RemoveAdvertisement(const DeviceIdPair& device_id_pair);
+
   // Sets the identified device to be returned by a IdentifyRemoteDevice() call.
   void SetIdentifiedDevice(const std::string& service_data,
                            cryptauth::RemoteDeviceRef identified_device,

components/cryptauth/background_eid_generator.cc

@@ -14,7 +14,6 @@
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/raw_eid_generator.h"
 #include "components/cryptauth/raw_eid_generator_impl.h"
-#include "components/cryptauth/remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/remote_device_ref.h"
 
 namespace cryptauth {
@@ -94,9 +93,8 @@ std::unique_ptr<DataWithTimestamp> BackgroundEidGenerator::GenerateEid(
 }
 
 std::string BackgroundEidGenerator::IdentifyRemoteDeviceByAdvertisement(
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
     const std::string& advertisement_service_data,
-    const std::vector<std::string>& device_ids) const {
+    const RemoteDeviceRefList& remote_devices) const {
   // Resize the service data to analyze only the first |kNumBytesInEidValue|
   // bytes. If there are any bytes after those first |kNumBytesInEidValue|
   // bytes, they are flags, so they are not needed to identify the device which
@@ -104,20 +102,11 @@ std::string BackgroundEidGenerator::IdentifyRemoteDeviceByAdvertisement(
   std::string service_data_without_flags = advertisement_service_data;
   service_data_without_flags.resize(RawEidGenerator::kNumBytesInEidValue);
 
-  const auto device_id_it = std::find_if(
-      device_ids.begin(), device_ids.end(),
-      [this, remote_beacon_seed_fetcher,
-       &service_data_without_flags](auto device_id) {
-        std::vector<BeaconSeed> beacon_seeds;
-        if (!remote_beacon_seed_fetcher->FetchSeedsForDeviceId(device_id,
-                                                               &beacon_seeds)) {
-          PA_LOG(WARNING) << "Error fetching beacon seeds for device with ID "
-                          << RemoteDeviceRef::TruncateDeviceIdForLogs(
-                                 device_id);
-          return false;
-        }
-
-        std::vector<DataWithTimestamp> eids = GenerateNearestEids(beacon_seeds);
+  const auto remote_device_it = std::find_if(
+      remote_devices.begin(), remote_devices.end(),
+      [this, &service_data_without_flags](const auto& remote_device) {
+        std::vector<DataWithTimestamp> eids =
+            GenerateNearestEids(remote_device.beacon_seeds());
         const auto eid_it = std::find_if(
             eids.begin(), eids.end(), [&service_data_without_flags](auto eid) {
               return eid.data == service_data_without_flags;
@@ -127,7 +116,9 @@ std::string BackgroundEidGenerator::IdentifyRemoteDeviceByAdvertisement(
       });
 
   // Return empty string if no matching device is found.
-  return device_id_it != device_ids.end() ? *device_id_it : std::string();
+  return remote_device_it != remote_devices.end()
+             ? remote_device_it->GetDeviceId()
+             : std::string();
 }
 
 }  // cryptauth

components/cryptauth/background_eid_generator.h

@@ -12,12 +12,12 @@
 #include "base/macros.h"
 #include "base/time/clock.h"
 #include "components/cryptauth/data_with_timestamp.h"
+#include "components/cryptauth/remote_device_ref.h"
 
 namespace cryptauth {
 
 class BeaconSeed;
 class RawEidGenerator;
-class RemoteBeaconSeedFetcher;
 
 // Generates ephemeral ID (EID) values that are broadcast for background BLE
 // advertisements in the ProximityAuth protocol.
@@ -43,14 +43,13 @@ class BackgroundEidGenerator {
   virtual std::vector<DataWithTimestamp> GenerateNearestEids(
       const std::vector<BeaconSeed>& beacon_seed) const;
 
-  // Given an incoming background advertisement with |service_data|, identifies
-  // which device (if any) sent the advertisement. Returns a device ID which
-  // identifies the device. If no device can be identified, returns an empty
-  // string.
+  // Given an incoming background advertisement with
+  // |advertisement_service_data|, identifies which device (if any) sent the
+  // advertisement. Returns a device ID which identifies the device. If no
+  // device can be identified, returns an empty string.
   virtual std::string IdentifyRemoteDeviceByAdvertisement(
-      cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
       const std::string& advertisement_service_data,
-      const std::vector<std::string>& device_ids) const;
+      const RemoteDeviceRefList& remote_devices) const;
 
  private:
   friend class CryptAuthBackgroundEidGeneratorTest;
@@ -59,7 +58,7 @@ class BackgroundEidGenerator {
 
   // Helper function to generate the EID for any |timestamp_ms|, properly
   // calculating the start of the period. Returns nullptr if |timestamp_ms| is
-  // outside of range of |beacon_seeds|.
+  // outside the range of |beacon_seeds|.
   std::unique_ptr<DataWithTimestamp> GenerateEid(
       int64_t timestamp_ms,
       const std::vector<BeaconSeed>& beacon_seeds) const;

components/cryptauth/background_eid_generator_unittest.cc

@@ -11,10 +11,10 @@
 #include "base/strings/string_util.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
-#include "components/cryptauth/mock_remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/raw_eid_generator_impl.h"
 #include "components/cryptauth/remote_device_ref.h"
+#include "components/cryptauth/remote_device_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -95,14 +95,19 @@ class CryptAuthBackgroundEidGeneratorTest : public testing::Test {
     beacon_seeds_.push_back(CreateBeaconSeed(
         kFourthSeed, kStartPeriodMs + 2 * kBeaconSeedDurationMs,
         kStartPeriodMs + 3 * kBeaconSeedDurationMs));
+
+    RemoteDeviceRef device_1 = RemoteDeviceRefBuilder()
+                                   .SetPublicKey("publicKey1")
+                                   .SetBeaconSeeds(beacon_seeds_)
+                                   .Build();
+    RemoteDeviceRef device_2 =
+        RemoteDeviceRefBuilder().SetPublicKey("publicKey2").Build();
+    test_remote_devices_ = {device_1, device_2};
   }
 
   void SetUp() override {
     SetTestTime(kCurrentTimeMs);
 
-    mock_seed_fetcher_ =
-        std::make_unique<cryptauth::MockRemoteBeaconSeedFetcher>();
-
     eid_generator_.reset(new BackgroundEidGenerator(
         std::make_unique<TestRawEidGenerator>(), &test_clock_));
   }
@@ -114,9 +119,9 @@ class CryptAuthBackgroundEidGeneratorTest : public testing::Test {
   }
 
   std::unique_ptr<BackgroundEidGenerator> eid_generator_;
-  std::unique_ptr<MockRemoteBeaconSeedFetcher> mock_seed_fetcher_;
   base::SimpleTestClock test_clock_;
   std::vector<BeaconSeed> beacon_seeds_;
+  RemoteDeviceRefList test_remote_devices_;
 };
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest,
@@ -228,11 +233,10 @@ TEST_F(CryptAuthBackgroundEidGeneratorTest,
   SetTestTime(kStartPeriodMs + kEidPeriodMs / 2);
   DataWithTimestamp advertisement_eid = CreateDataWithTimestamp(
       beacon_seeds_[0].data(), kStartPeriodMs - kEidPeriodMs);
-  mock_seed_fetcher_->SetSeedsForDeviceId(kDeviceId1, &beacon_seeds_);
 
-  EXPECT_EQ(std::string(), eid_generator_->IdentifyRemoteDeviceByAdvertisement(
-                               mock_seed_fetcher_.get(), advertisement_eid.data,
-                               {kDeviceId2}));
+  EXPECT_EQ(std::string(),
+            eid_generator_->IdentifyRemoteDeviceByAdvertisement(
+                advertisement_eid.data, {test_remote_devices_[1]}));
 }
 
 TEST_F(CryptAuthBackgroundEidGeneratorTest,
@@ -240,11 +244,10 @@ TEST_F(CryptAuthBackgroundEidGeneratorTest,
   SetTestTime(kStartPeriodMs + kEidPeriodMs / 2);
   DataWithTimestamp advertisement_eid = CreateDataWithTimestamp(
       beacon_seeds_[0].data(), kStartPeriodMs - kEidPeriodMs);
-  mock_seed_fetcher_->SetSeedsForDeviceId(kDeviceId1, &beacon_seeds_);
 
-  EXPECT_EQ(kDeviceId1, eid_generator_->IdentifyRemoteDeviceByAdvertisement(
-                            mock_seed_fetcher_.get(), advertisement_eid.data,
-                            {kDeviceId1, kDeviceId2}));
+  EXPECT_EQ(test_remote_devices_[0].GetDeviceId(),
+            eid_generator_->IdentifyRemoteDeviceByAdvertisement(
+                advertisement_eid.data, test_remote_devices_));
 }
 
 }  // namespace cryptauth

components/cryptauth/ble/ble_advertisement_generator.cc

@@ -8,8 +8,6 @@
 #include <vector>
 
 #include "chromeos/components/proximity_auth/logging/logging.h"
-#include "components/cryptauth/local_device_data_provider.h"
-#include "components/cryptauth/remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/remote_device_ref.h"
 
 namespace cryptauth {
@@ -20,14 +18,13 @@ BleAdvertisementGenerator* BleAdvertisementGenerator::instance_ = nullptr;
 // static
 std::unique_ptr<DataWithTimestamp>
 BleAdvertisementGenerator::GenerateBleAdvertisement(
-    const std::string& device_id,
-    LocalDeviceDataProvider* local_device_data_provider,
-    RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) {
+    RemoteDeviceRef remote_device,
+    const std::string& local_device_public_key) {
   if (!instance_)
     instance_ = new BleAdvertisementGenerator();
 
-  return instance_->GenerateBleAdvertisementInternal(
-      device_id, local_device_data_provider, remote_beacon_seed_fetcher);
+  return instance_->GenerateBleAdvertisementInternal(remote_device,
+                                                     local_device_public_key);
 }
 
 // static
@@ -43,48 +40,27 @@ BleAdvertisementGenerator::~BleAdvertisementGenerator() {}
 
 std::unique_ptr<DataWithTimestamp>
 BleAdvertisementGenerator::GenerateBleAdvertisementInternal(
-    const std::string& device_id,
-    LocalDeviceDataProvider* local_device_data_provider,
-    RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) {
-  std::string local_device_public_key;
-  if (!local_device_data_provider->GetLocalDeviceData(&local_device_public_key,
-                                                      nullptr)) {
-    PA_LOG(WARNING) << "Error fetching the local device's public key. Cannot "
-                    << "advertise without the public key.";
-    return nullptr;
-  }
-
+    RemoteDeviceRef remote_device,
+    const std::string& local_device_public_key) {
   if (local_device_public_key.empty()) {
     PA_LOG(WARNING) << "Local device's public key is empty. Cannot advertise "
                     << "with an invalid key.";
     return nullptr;
   }
 
-  std::vector<BeaconSeed> remote_beacon_seeds;
-  if (!remote_beacon_seed_fetcher->FetchSeedsForDeviceId(
-          device_id, &remote_beacon_seeds)) {
-    PA_LOG(WARNING) << "Error fetching beacon seeds for device with ID "
-                    << RemoteDeviceRef::TruncateDeviceIdForLogs(device_id)
-                    << ". "
-                    << "Cannot advertise without seeds.";
-    return nullptr;
-  }
-
-  if (remote_beacon_seeds.empty()) {
+  if (remote_device.beacon_seeds().empty()) {
     PA_LOG(WARNING) << "No synced seeds exist for device with ID "
-                    << RemoteDeviceRef::TruncateDeviceIdForLogs(device_id)
-                    << ". "
+                    << remote_device.GetTruncatedDeviceIdForLogs() << ". "
                     << "Cannot advertise without seeds.";
     return nullptr;
   }
 
   std::unique_ptr<DataWithTimestamp> service_data =
       eid_generator_->GenerateAdvertisement(local_device_public_key,
-                                            remote_beacon_seeds);
+                                            remote_device.beacon_seeds());
   if (!service_data) {
     PA_LOG(WARNING) << "Error generating advertisement for device with ID "
-                    << RemoteDeviceRef::TruncateDeviceIdForLogs(device_id)
-                    << ". "
+                    << remote_device.GetTruncatedDeviceIdForLogs() << ". "
                     << "Cannot advertise.";
     return nullptr;
   }

components/cryptauth/ble/ble_advertisement_generator.h

@@ -13,25 +13,24 @@
 namespace chromeos {
 namespace tether {
 class BleAdvertiserImplTest;
+class BleServiceDataHelperImplTest;
 class AdHocBleAdvertiserImplTest;
 }  // namespace tether
 }  // namespace chromeos
 
 namespace cryptauth {
 
-class LocalDeviceDataProvider;
-class RemoteBeaconSeedFetcher;
+class RemoteDeviceRef;
 
 // Generates advertisements for the ProximityAuth BLE advertisement scheme.
 class BleAdvertisementGenerator {
  public:
-  // Generates an advertisement from the current device to the device with ID
-  // |device_id|. The generated advertisement should be used immediately since
-  // it is based on the current timestamp.
+  // Generates an advertisement from the current device to |remote_device|. The
+  // generated advertisement should be used immediately since it is based on the
+  // current timestamp.
   static std::unique_ptr<DataWithTimestamp> GenerateBleAdvertisement(
-      const std::string& device_id,
-      LocalDeviceDataProvider* local_device_data_provider,
-      RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher);
+      RemoteDeviceRef remote_device,
+      const std::string& local_device_public_key);
 
   virtual ~BleAdvertisementGenerator();
 
@@ -39,13 +38,13 @@ class BleAdvertisementGenerator {
   BleAdvertisementGenerator();
 
   virtual std::unique_ptr<DataWithTimestamp> GenerateBleAdvertisementInternal(
-      const std::string& device_id,
-      LocalDeviceDataProvider* local_device_data_provider,
-      RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher);
+      RemoteDeviceRef remote_device,
+      const std::string& local_device_public_key);
 
  private:
   friend class CryptAuthBleAdvertisementGeneratorTest;
   friend class chromeos::tether::BleAdvertiserImplTest;
+  friend class chromeos::tether::BleServiceDataHelperImplTest;
   friend class chromeos::tether::AdHocBleAdvertiserImplTest;
 
   static BleAdvertisementGenerator* instance_;

components/cryptauth/ble/ble_advertisement_generator_unittest.cc

@@ -11,8 +11,6 @@
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "components/cryptauth/mock_foreground_eid_generator.h"
-#include "components/cryptauth/mock_local_device_data_provider.h"
-#include "components/cryptauth/mock_remote_beacon_seed_fetcher.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/remote_device_ref.h"
 #include "components/cryptauth/remote_device_test_util.h"
@@ -25,17 +23,17 @@ namespace cryptauth {
 
 namespace {
 
-const char kFakePublicKey[] = "fakePublicKey";
+const char kLocalDevicePublicKey[] = "localDevicePublicKey";
 
-std::vector<BeaconSeed> CreateFakeBeaconSeedsForDevice(
-    RemoteDeviceRef remote_device) {
+std::vector<BeaconSeed> CreateBeaconSeedsForDevice(
+    const std::string& device_id) {
   BeaconSeed seed1;
-  seed1.set_data("seed1Data" + remote_device.GetTruncatedDeviceIdForLogs());
+  seed1.set_data("seed1Data" + device_id);
   seed1.set_start_time_millis(1000L);
   seed1.set_start_time_millis(2000L);
 
   BeaconSeed seed2;
-  seed2.set_data("seed2Data" + remote_device.GetTruncatedDeviceIdForLogs());
+  seed2.set_data("seed2Data" + device_id);
   seed2.set_start_time_millis(2000L);
   seed2.set_start_time_millis(3000L);
 
@@ -48,20 +46,13 @@ std::vector<BeaconSeed> CreateFakeBeaconSeedsForDevice(
 class CryptAuthBleAdvertisementGeneratorTest : public testing::Test {
  protected:
   CryptAuthBleAdvertisementGeneratorTest()
-      : fake_device_(CreateRemoteDeviceRefListForTest(1)[0]),
+      : test_remote_device_(
+            RemoteDeviceRefBuilder()
+                .SetBeaconSeeds(CreateBeaconSeedsForDevice("remote device id"))
+                .Build()),
         fake_advertisement_("advertisement1", 1000L, 2000L) {}
 
   void SetUp() override {
-    mock_seed_fetcher_ = std::make_unique<MockRemoteBeaconSeedFetcher>();
-    std::vector<BeaconSeed> device_0_beacon_seeds =
-        CreateFakeBeaconSeedsForDevice(fake_device_);
-    mock_seed_fetcher_->SetSeedsForDeviceId(fake_device_.GetDeviceId(),
-                                            &device_0_beacon_seeds);
-
-    mock_local_data_provider_ = std::make_unique<MockLocalDeviceDataProvider>();
-    mock_local_data_provider_->SetPublicKey(
-        std::make_unique<std::string>(kFakePublicKey));
-
     generator_ = base::WrapUnique(new BleAdvertisementGenerator());
 
     mock_eid_generator_ = new MockForegroundEidGenerator();
@@ -71,18 +62,16 @@ class CryptAuthBleAdvertisementGeneratorTest : public testing::Test {
 
   void TearDown() override { generator_.reset(); }
 
-  std::unique_ptr<DataWithTimestamp> GenerateBleAdvertisement() {
+  std::unique_ptr<DataWithTimestamp> CallGenerateBleAdvertisement(
+      RemoteDeviceRef remote_device,
+      const std::string& local_device_public_key) {
     return generator_->GenerateBleAdvertisementInternal(
-        fake_device_.GetDeviceId(), mock_local_data_provider_.get(),
-        mock_seed_fetcher_.get());
+        remote_device, local_device_public_key);
   }
 
-  const RemoteDeviceRef fake_device_;
+  const RemoteDeviceRef test_remote_device_;
   const DataWithTimestamp fake_advertisement_;
 
-  std::unique_ptr<MockRemoteBeaconSeedFetcher> mock_seed_fetcher_;
-  std::unique_ptr<MockLocalDeviceDataProvider> mock_local_data_provider_;
-
   MockForegroundEidGenerator* mock_eid_generator_;
 
   std::unique_ptr<BleAdvertisementGenerator> generator_;
@@ -91,37 +80,28 @@ class CryptAuthBleAdvertisementGeneratorTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(CryptAuthBleAdvertisementGeneratorTest);
 };
 
-TEST_F(CryptAuthBleAdvertisementGeneratorTest, TestCannotFetchPublicKey) {
-  mock_local_data_provider_->SetPublicKey(nullptr);
-  EXPECT_EQ(nullptr, GenerateBleAdvertisement());
-}
-
 TEST_F(CryptAuthBleAdvertisementGeneratorTest, EmptyPublicKey) {
-  mock_local_data_provider_->SetPublicKey(std::make_unique<std::string>(""));
-  EXPECT_EQ(nullptr, GenerateBleAdvertisement());
-}
-
-TEST_F(CryptAuthBleAdvertisementGeneratorTest, NoBeaconSeeds) {
-  mock_seed_fetcher_->SetSeedsForDeviceId(fake_device_.GetDeviceId(), nullptr);
-  EXPECT_EQ(nullptr, GenerateBleAdvertisement());
+  EXPECT_FALSE(
+      CallGenerateBleAdvertisement(test_remote_device_, std::string()));
 }
 
 TEST_F(CryptAuthBleAdvertisementGeneratorTest, EmptyBeaconSeeds) {
-  std::vector<BeaconSeed> empty_seeds;
-  mock_seed_fetcher_->SetSeedsForDeviceId(fake_device_.GetDeviceId(),
-                                          &empty_seeds);
-  EXPECT_EQ(nullptr, GenerateBleAdvertisement());
+  EXPECT_FALSE(CallGenerateBleAdvertisement(CreateRemoteDeviceRefForTest(),
+                                            kLocalDevicePublicKey));
 }
 
 TEST_F(CryptAuthBleAdvertisementGeneratorTest, CannotGenerateAdvertisement) {
   mock_eid_generator_->set_advertisement(nullptr);
-  EXPECT_EQ(nullptr, GenerateBleAdvertisement());
+  EXPECT_FALSE(
+      CallGenerateBleAdvertisement(test_remote_device_, kLocalDevicePublicKey));
 }
 
 TEST_F(CryptAuthBleAdvertisementGeneratorTest, AdvertisementGenerated) {
   mock_eid_generator_->set_advertisement(
       std::make_unique<DataWithTimestamp>(fake_advertisement_));
-  EXPECT_EQ(fake_advertisement_, *GenerateBleAdvertisement());
+  EXPECT_EQ(fake_advertisement_,
+            *CallGenerateBleAdvertisement(test_remote_device_,
+                                          kLocalDevicePublicKey));
 }
 
 }  // namespace cryptauth

components/cryptauth/ble/fake_ble_advertisement_generator.cc

@@ -4,6 +4,8 @@
 
 #include "components/cryptauth/ble/fake_ble_advertisement_generator.h"
 
+#include "components/cryptauth/remote_device_ref.h"
+
 namespace cryptauth {
 
 FakeBleAdvertisementGenerator::FakeBleAdvertisementGenerator() {}
@@ -12,9 +14,8 @@ FakeBleAdvertisementGenerator::~FakeBleAdvertisementGenerator() {}
 
 std::unique_ptr<DataWithTimestamp>
 FakeBleAdvertisementGenerator::GenerateBleAdvertisementInternal(
-    const std::string& device_id,
-    LocalDeviceDataProvider* local_device_data_provider,
-    RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) {
+    RemoteDeviceRef remote_device,
+    const std::string& local_device_public_key) {
   return std::move(advertisement_);
 }
 

components/cryptauth/ble/fake_ble_advertisement_generator.h

@@ -27,9 +27,8 @@ class FakeBleAdvertisementGenerator : public BleAdvertisementGenerator {
 
  protected:
   std::unique_ptr<DataWithTimestamp> GenerateBleAdvertisementInternal(
-      const std::string& device_id,
-      LocalDeviceDataProvider* local_device_data_provider,
-      RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) override;
+      RemoteDeviceRef remote_device,
+      const std::string& local_device_public_key) override;
 
  private:
   std::unique_ptr<DataWithTimestamp> advertisement_;

components/cryptauth/fake_background_eid_generator.cc

@@ -17,9 +17,8 @@ std::vector<DataWithTimestamp> FakeBackgroundEidGenerator::GenerateNearestEids(
 }
 
 std::string FakeBackgroundEidGenerator::IdentifyRemoteDeviceByAdvertisement(
-    cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
     const std::string& advertisement_service_data,
-    const std::vector<std::string>& device_ids) const {
+    const RemoteDeviceRefList& remote_devices) const {
   // Increment num_identify_calls_. Since this overrides a const method, some
   // hacking is needed to modify the num_identify_calls_ instance variable.
   int* num_identify_calls_ptr = const_cast<int*>(&num_identify_calls_);

components/cryptauth/fake_background_eid_generator.h

@@ -25,9 +25,8 @@ class FakeBackgroundEidGenerator : public BackgroundEidGenerator {
   std::vector<DataWithTimestamp> GenerateNearestEids(
       const std::vector<BeaconSeed>& beacon_seed) const override;
   std::string IdentifyRemoteDeviceByAdvertisement(
-      cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
       const std::string& advertisement_service_data,
-      const std::vector<std::string>& device_ids) const override;
+      const RemoteDeviceRefList& remote_devices) const override;
 
   void set_nearest_eids_(
       std::unique_ptr<std::vector<DataWithTimestamp>> nearest_eids) {

components/cryptauth/remote_device_test_util.cc

@@ -63,6 +63,12 @@ RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetLastUpdateTimeMillis(
   return *this;
 }
 
+RemoteDeviceRefBuilder& RemoteDeviceRefBuilder::SetBeaconSeeds(
+    const std::vector<BeaconSeed>& beacon_seeds) {
+  remote_device_->beacon_seeds = beacon_seeds;
+  return *this;
+}
+
 RemoteDeviceRef RemoteDeviceRefBuilder::Build() {
   return RemoteDeviceRef(remote_device_);
 }

components/cryptauth/remote_device_test_util.h

@@ -31,6 +31,8 @@ class RemoteDeviceRefBuilder {
       const SoftwareFeatureState new_state);
   RemoteDeviceRefBuilder& SetLastUpdateTimeMillis(
       int64_t last_update_time_millis);
+  RemoteDeviceRefBuilder& SetBeaconSeeds(
+      const std::vector<BeaconSeed>& beacon_seeds);
   RemoteDeviceRef Build();
 
  private: