BASELINE: Update Chromium to 69.0.3497.70

Change-Id: I2b7b56e4e7a8b26656930def0d4575dc32b900a0
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

8 files changed, 140 insertions, 138 deletions

diff --git a/chromium/components/cryptauth/ble/ble_advertisement_generator.cc b/chromium/components/cryptauth/ble/ble_advertisement_generator.cc
index b9eea585cc1..b5cf567543b 100644
--- a/chromium/components/cryptauth/ble/ble_advertisement_generator.cc
+++ b/chromium/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;
   }
diff --git a/chromium/components/cryptauth/ble/ble_advertisement_generator.h b/chromium/components/cryptauth/ble/ble_advertisement_generator.h
index 38b8d8f01f9..7a5acba2af7 100644
--- a/chromium/components/cryptauth/ble/ble_advertisement_generator.h
+++ b/chromium/components/cryptauth/ble/ble_advertisement_generator.h
@@ -11,27 +11,29 @@
 #include "components/cryptauth/foreground_eid_generator.h"
 
 namespace chromeos {
+namespace secure_channel {
+class SecureChannelBleServiceDataHelperImplTest;
+}  // namespace secure_channel
 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 +41,15 @@ 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::secure_channel::
+      SecureChannelBleServiceDataHelperImplTest;
   friend class chromeos::tether::BleAdvertiserImplTest;
+  friend class chromeos::tether::BleServiceDataHelperImplTest;
   friend class chromeos::tether::AdHocBleAdvertiserImplTest;
 
   static BleAdvertisementGenerator* instance_;
diff --git a/chromium/components/cryptauth/ble/ble_advertisement_generator_unittest.cc b/chromium/components/cryptauth/ble/ble_advertisement_generator_unittest.cc
index 9a2cb064605..568abdd0129 100644
--- a/chromium/components/cryptauth/ble/ble_advertisement_generator_unittest.cc
+++ b/chromium/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
diff --git a/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.cc b/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.cc
index ae753447aa4..d060e2350ff 100644
--- a/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.cc
+++ b/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.cc
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ -269,18 +270,6 @@ void BluetoothLowEnergyWeaveClientConnection::DestroyConnection(
     RecordBleWeaveConnectionResult(result);
   }
 
-  if (result ==
-          BleWeaveConnectionResult::
-              BLE_WEAVE_CONNECTION_RESULT_TIMEOUT_FINDING_GATT_CHARACTERISTICS ||
-      result ==
-          BleWeaveConnectionResult::
-              BLE_WEAVE_CONNECTION_RESULT_ERROR_FINDING_GATT_CHARACTERISTICS ||
-      result ==
-          BleWeaveConnectionResult::
-              BLE_WEAVE_CONNECTION_RESULT_ERROR_GATT_CHARACTERISTIC_NOT_AVAILABLE) {
-    NotifyGattCharacteristicsNotAvailable();
-  }
-
   if (adapter_) {
     adapter_->RemoveObserver(this);
     adapter_ = nullptr;
@@ -371,7 +360,7 @@ void BluetoothLowEnergyWeaveClientConnection::OnTimeoutForSubStatus(
 
 void BluetoothLowEnergyWeaveClientConnection::SetupTestDoubles(
     scoped_refptr<base::TaskRunner> test_task_runner,
-    std::unique_ptr<base::Timer> test_timer,
+    std::unique_ptr<base::OneShotTimer> test_timer,
     std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> test_generator,
     std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> test_receiver) {
   task_runner_ = test_task_runner;
@@ -875,6 +864,34 @@ std::string BluetoothLowEnergyWeaveClientConnection::GetDeviceAddress() {
                           : bluetooth_device_->GetAddress();
 }
 
+void BluetoothLowEnergyWeaveClientConnection::GetConnectionRssi(
+    base::OnceCallback<void(base::Optional<int32_t>)> callback) {
+  device::BluetoothDevice* device = GetBluetoothDevice();
+
+  if (!device || !device->IsConnected()) {
+    std::move(callback).Run(base::nullopt);
+    return;
+  }
+
+  // device::BluetoothDevice has not converted to using a base::OnceCallback
+  // instead of a base::Callback, so use a wrapper for now.
+  auto callback_holder = base::AdaptCallbackForRepeating(std::move(callback));
+  device->GetConnectionInfo(
+      base::Bind(&BluetoothLowEnergyWeaveClientConnection::OnConnectionInfo,
+                 weak_ptr_factory_.GetWeakPtr(), callback_holder));
+}
+
+void BluetoothLowEnergyWeaveClientConnection::OnConnectionInfo(
+    base::RepeatingCallback<void(base::Optional<int32_t>)> rssi_callback,
+    const device::BluetoothDevice::ConnectionInfo& connection_info) {
+  if (connection_info.rssi == device::BluetoothDevice::kUnknownPower) {
+    std::move(rssi_callback).Run(base::nullopt);
+    return;
+  }
+
+  std::move(rssi_callback).Run(connection_info.rssi);
+}
+
 device::BluetoothDevice*
 BluetoothLowEnergyWeaveClientConnection::GetBluetoothDevice() {
   return bluetooth_device_;
diff --git a/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h b/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h
index 54d3bf96fdd..716a5384911 100644
--- a/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h
+++ b/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h
@@ -15,6 +15,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/optional.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/cryptauth/ble/bluetooth_low_energy_characteristics_finder.h"
@@ -103,6 +104,8 @@ class BluetoothLowEnergyWeaveClientConnection
   void Connect() override;
   void Disconnect() override;
   std::string GetDeviceAddress() override;
+  void GetConnectionRssi(
+      base::OnceCallback<void(base::Optional<int32_t>)> callback) override;
 
  protected:
   enum BleWeaveConnectionResult {
@@ -134,7 +137,7 @@ class BluetoothLowEnergyWeaveClientConnection
 
   void SetupTestDoubles(
       scoped_refptr<base::TaskRunner> test_task_runner,
-      std::unique_ptr<base::Timer> test_timer,
+      std::unique_ptr<base::OneShotTimer> test_timer,
       std::unique_ptr<BluetoothLowEnergyWeavePacketGenerator> test_generator,
       std::unique_ptr<BluetoothLowEnergyWeavePacketReceiver> test_receiver);
 
@@ -298,6 +301,10 @@ class BluetoothLowEnergyWeaveClientConnection
   void SetSubStatus(SubStatus status);
   void OnTimeoutForSubStatus(SubStatus status);
 
+  void OnConnectionInfo(
+      base::RepeatingCallback<void(base::Optional<int32_t>)> rssi_callback,
+      const device::BluetoothDevice::ConnectionInfo& connection_info);
+
   // These functions are used to set up the connection so that it is ready to
   // send/receive data.
   void SetConnectionLatency();
@@ -374,7 +381,7 @@ class BluetoothLowEnergyWeaveClientConnection
   RemoteAttribute tx_characteristic_;
   RemoteAttribute rx_characteristic_;
   scoped_refptr<base::TaskRunner> task_runner_;
-  std::unique_ptr<base::Timer> timer_;
+  std::unique_ptr<base::OneShotTimer> timer_;
 
   // These pointers start out null and are created during the connection
   // process.
diff --git a/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection_unittest.cc b/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection_unittest.cc
index d95625a3caf..3a260fe5f61 100644
--- a/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection_unittest.cc
+++ b/chromium/components/cryptauth/ble/bluetooth_low_energy_weave_client_connection_unittest.cc
@@ -13,7 +13,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/test/histogram_tester.h"
+#include "base/test/metrics/histogram_tester.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
@@ -268,7 +268,6 @@ class MockConnectionObserver : public ConnectionObserver {
   MockConnectionObserver(Connection* connection)
       : connection_(connection),
         num_send_completed_(0),
-        num_gatt_services_unavailable_events_(0),
         delete_on_disconnect_(false),
         delete_on_message_sent_(false) {}
 
@@ -280,10 +279,6 @@ class MockConnectionObserver : public ConnectionObserver {
 
   int num_send_completed() { return num_send_completed_; }
 
-  int num_gatt_services_unavailable_events() {
-    return num_gatt_services_unavailable_events_;
-  }
-
   bool delete_on_disconnect() { return delete_on_disconnect_; }
 
   void set_delete_on_disconnect(bool delete_on_disconnect) {
@@ -316,16 +311,11 @@ class MockConnectionObserver : public ConnectionObserver {
       delete connection_;
   }
 
-  void OnGattCharacteristicsNotAvailable() override {
-    ++num_gatt_services_unavailable_events_;
-  }
-
  private:
   Connection* connection_;
   std::string last_deserialized_message_;
   bool last_send_success_;
   int num_send_completed_;
-  int num_gatt_services_unavailable_events_;
   bool delete_on_disconnect_;
   bool delete_on_message_sent_;
 };
@@ -347,7 +337,6 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
     generator_ = nullptr;
     receiver_ = nullptr;
     has_verified_connection_result_ = false;
-    has_verified_gatt_services_event_ = false;
     connection_observer_.reset();
 
     adapter_ = base::MakeRefCounted<NiceMock<device::MockBluetoothAdapter>>();
@@ -377,6 +366,11 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
         .WillByDefault(Return(mock_bluetooth_device_.get()));
     ON_CALL(*mock_bluetooth_device_, GetGattService(kServiceID))
         .WillByDefault(Return(service_.get()));
+    ON_CALL(*mock_bluetooth_device_, IsConnected()).WillByDefault(Return(true));
+    ON_CALL(*mock_bluetooth_device_, GetConnectionInfo(_))
+        .WillByDefault(
+            Invoke(this, &CryptAuthBluetoothLowEnergyWeaveClientConnectionTest::
+                             MockGetConnectionInfo));
     ON_CALL(*service_, GetCharacteristic(kRXCharacteristicID))
         .WillByDefault(Return(rx_characteristic_.get()));
     ON_CALL(*service_, GetCharacteristic(kTXCharacteristicID))
@@ -386,11 +380,6 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
   }
 
   void TearDown() override {
-    ASSERT_TRUE(has_verified_connection_result_);
-    if (connection_observer_ && !has_verified_gatt_services_event_) {
-      EXPECT_EQ(0,
-                connection_observer_->num_gatt_services_unavailable_events());
-    }
     connection_observer_.reset();
   }
 
@@ -414,8 +403,7 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
         base::WrapUnique(new MockConnectionObserver(connection.get()));
     connection->AddObserver(connection_observer_.get());
 
-    test_timer_ = new base::MockTimer(false /* retains_user_task */,
-                                      false /* is_repeating */);
+    test_timer_ = new base::MockOneShotTimer();
     generator_ = new NiceMock<MockBluetoothLowEnergyWeavePacketGenerator>();
     receiver_ = new NiceMock<MockBluetoothLowEnergyWeavePacketReceiver>();
     connection->SetupTestDoubles(task_runner_, base::WrapUnique(test_timer_),
@@ -634,11 +622,6 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
     has_verified_connection_result_ = true;
   }
 
-  void VerifyGattServicesUnavailableEventSent() {
-    EXPECT_EQ(1, connection_observer_->num_gatt_services_unavailable_events());
-    has_verified_gatt_services_event_ = true;
-  }
-
   BluetoothLowEnergyWeaveClientConnection::GattServiceOperationResult
   GattServiceOperationResultSuccessOrFailure(bool success) {
     return success ? BluetoothLowEnergyWeaveClientConnection::
@@ -649,6 +632,18 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
                              GATT_SERVICE_OPERATION_RESULT_GATT_ERROR_UNKNOWN;
   }
 
+  base::Optional<int32_t> GetRssi(
+      TestBluetoothLowEnergyWeaveClientConnection* connection) {
+    connection->GetConnectionRssi(base::BindOnce(
+        &CryptAuthBluetoothLowEnergyWeaveClientConnectionTest::OnConnectionRssi,
+        base::Unretained(this)));
+
+    base::Optional<int32_t> rssi = rssi_;
+    rssi_.reset();
+
+    return rssi;
+  }
+
  protected:
   const RemoteDeviceRef remote_device_;
   const device::BluetoothUUID service_uuid_;
@@ -657,7 +652,7 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
   const proximity_auth::ScopedDisableLoggingForTesting disable_logging_;
 
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
-  base::MockTimer* test_timer_;
+  base::MockOneShotTimer* test_timer_;
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 
   std::unique_ptr<device::MockBluetoothDevice> mock_bluetooth_device_;
@@ -666,9 +661,9 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
   std::unique_ptr<device::MockBluetoothGattCharacteristic> rx_characteristic_;
   std::vector<uint8_t> last_value_written_on_tx_characteristic_;
   base::MessageLoop message_loop_;
+  int32_t rssi_for_channel_ = device::BluetoothDevice::kUnknownPower;
   bool last_wire_message_success_;
   bool has_verified_connection_result_;
-  bool has_verified_gatt_services_event_;
   NiceMock<MockBluetoothLowEnergyWeavePacketGenerator>* generator_;
   NiceMock<MockBluetoothLowEnergyWeavePacketReceiver>* receiver_;
   std::unique_ptr<MockConnectionObserver> connection_observer_;
@@ -698,6 +693,16 @@ class CryptAuthBluetoothLowEnergyWeaveClientConnectionTest
   base::HistogramTester histogram_tester_;
 
  private:
+  void MockGetConnectionInfo(
+      const device::BluetoothDevice::ConnectionInfoCallback& callback) {
+    callback.Run(device::BluetoothDevice::ConnectionInfo(
+        rssi_for_channel_, 0 /* transmit_power */, 0 /* max_transmit_power */));
+  }
+
+  void OnConnectionRssi(base::Optional<int32_t> rssi) { rssi_ = rssi; }
+
+  base::Optional<int32_t> rssi_;
+
   DISALLOW_COPY_AND_ASSIGN(
       CryptAuthBluetoothLowEnergyWeaveClientConnectionTest);
 };
@@ -853,7 +858,6 @@ TEST_F(CryptAuthBluetoothLowEnergyWeaveClientConnectionTest,
   EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::Status::DISCONNECTED);
 
-  VerifyGattServicesUnavailableEventSent();
   VerifyBleWeaveConnectionResult(
       BluetoothLowEnergyWeaveClientConnection::BleWeaveConnectionResult::
           BLE_WEAVE_CONNECTION_RESULT_ERROR_FINDING_GATT_CHARACTERISTICS);
@@ -880,7 +884,6 @@ TEST_F(CryptAuthBluetoothLowEnergyWeaveClientConnectionTest,
   EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::Status::DISCONNECTED);
 
-  VerifyGattServicesUnavailableEventSent();
   VerifyBleWeaveConnectionResult(
       BluetoothLowEnergyWeaveClientConnection::BleWeaveConnectionResult::
           BLE_WEAVE_CONNECTION_RESULT_ERROR_GATT_CHARACTERISTIC_NOT_AVAILABLE);
@@ -1509,7 +1512,6 @@ TEST_F(CryptAuthBluetoothLowEnergyWeaveClientConnectionTest,
   EXPECT_EQ(connection->sub_status(), SubStatus::DISCONNECTED);
   EXPECT_EQ(connection->status(), Connection::Status::DISCONNECTED);
 
-  VerifyGattServicesUnavailableEventSent();
   VerifyBleWeaveConnectionResult(
       BluetoothLowEnergyWeaveClientConnection::BleWeaveConnectionResult::
           BLE_WEAVE_CONNECTION_RESULT_TIMEOUT_FINDING_GATT_CHARACTERISTICS);
@@ -1578,6 +1580,22 @@ TEST_F(CryptAuthBluetoothLowEnergyWeaveClientConnectionTest,
           BLE_WEAVE_CONNECTION_RESULT_TIMEOUT_WAITING_FOR_MESSAGE_TO_SEND);
 }
 
+TEST_F(CryptAuthBluetoothLowEnergyWeaveClientConnectionTest, GetRssi) {
+  std::unique_ptr<TestBluetoothLowEnergyWeaveClientConnection> connection(
+      CreateConnection(true /* should_set_low_connection_latency */));
+
+  EXPECT_FALSE(GetRssi(connection.get()));
+
+  rssi_for_channel_ = -50;
+  EXPECT_EQ(-50, GetRssi(connection.get()));
+
+  rssi_for_channel_ = -40;
+  EXPECT_EQ(-40, GetRssi(connection.get()));
+
+  rssi_for_channel_ = -30;
+  EXPECT_EQ(-30, GetRssi(connection.get()));
+}
+
 }  // namespace weave
 
 }  // namespace cryptauth
diff --git a/chromium/components/cryptauth/ble/fake_ble_advertisement_generator.cc b/chromium/components/cryptauth/ble/fake_ble_advertisement_generator.cc
index f95ad9e4e4c..369175d7761 100644
--- a/chromium/components/cryptauth/ble/fake_ble_advertisement_generator.cc
+++ b/chromium/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_);
 }
 
diff --git a/chromium/components/cryptauth/ble/fake_ble_advertisement_generator.h b/chromium/components/cryptauth/ble/fake_ble_advertisement_generator.h
index 1dad8026a72..d74290f8623 100644
--- a/chromium/components/cryptauth/ble/fake_ble_advertisement_generator.h
+++ b/chromium/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_;