[CrOS Tether] Ensure that BleAdvertiser explicitly calls Unregister() on all advertisements after t…

chromeos/components/tether/ble_advertiser_unittest.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/components/tether/ble_advertiser.h"
 
 #include "base/logging.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/mock_local_device_data_provider.h"
 #include "components/cryptauth/mock_eid_generator.h"
@@ skipping 94 matching lines @@
   seed2.set_start_time_millis(3000L);
 
   std::vector<cryptauth::BeaconSeed> seeds = {seed1, seed2};
   return seeds;
 };
 
 }  // namespace
 
 class BleAdvertiserTest : public testing::Test {
  protected:
+  class TestBleAdvertisementUnregisterHandler
+      : public BleAdvertiser::BleAdvertisementUnregisterHandler {
+   public:
+    TestBleAdvertisementUnregisterHandler()
+        : num_advertisements_unregistered_(0) {}
+    ~TestBleAdvertisementUnregisterHandler() {}
+
+    size_t num_advertisements_unregistered() {
+      return num_advertisements_unregistered_;
+    }
+
+    // BleAdvertiser::BleAdvertisementUnregisterHandler:
+    void OnAdvertisementUnregisterSuccess() override {
+      num_advertisements_unregistered_++;
+    }
+
+    void OnAdvertisementUnregisterFailure(
+        device::BluetoothAdvertisement::ErrorCode error_code) override {}
+
+   private:
+    size_t num_advertisements_unregistered_;
+  };
+
   BleAdvertiserTest()
       : fake_devices_(cryptauth::GenerateTestRemoteDevices(3)),
         fake_advertisements_(GenerateFakeAdvertisements()) {}
 
   void SetUp() override {
     individual_advertisements_.clear();
     register_advertisement_args_.clear();
 
     mock_adapter_ = make_scoped_refptr(
         new StrictMock<MockBluetoothAdapterWithAdvertisements>());
     ON_CALL(*mock_adapter_, AddObserver(_))
         .WillByDefault(Invoke(this, &BleAdvertiserTest::OnAdapterAddObserver));
     ON_CALL(*mock_adapter_, RemoveObserver(_))
         .WillByDefault(
             Invoke(this, &BleAdvertiserTest::OnAdapterRemoveObserver));
     ON_CALL(*mock_adapter_, IsPowered()).WillByDefault(Return(true));
     ON_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_))
         .WillByDefault(
             Invoke(this, &BleAdvertiserTest::OnAdapterRegisterAdvertisement));
 
+    test_unregister_handler_ = new TestBleAdvertisementUnregisterHandler();
+
     mock_eid_generator_ = base::MakeUnique<cryptauth::MockEidGenerator>();
 
     mock_seed_fetcher_ =
         base::MakeUnique<cryptauth::MockRemoteBeaconSeedFetcher>();
     std::vector<cryptauth::BeaconSeed> device_0_beacon_seeds =
         CreateFakeBeaconSeedsForDevice(fake_devices_[0]);
     std::vector<cryptauth::BeaconSeed> device_1_beacon_seeds =
         CreateFakeBeaconSeedsForDevice(fake_devices_[1]);
     std::vector<cryptauth::BeaconSeed> device_2_beacon_seeds =
         CreateFakeBeaconSeedsForDevice(fake_devices_[2]);
     mock_seed_fetcher_->SetSeedsForDevice(fake_devices_[0],
                                           &device_0_beacon_seeds);
     mock_seed_fetcher_->SetSeedsForDevice(fake_devices_[1],
                                           &device_1_beacon_seeds);
     mock_seed_fetcher_->SetSeedsForDevice(fake_devices_[2],
                                           &device_2_beacon_seeds);
 
     mock_local_data_provider_ = base::MakeUnique<MockLocalDeviceDataProvider>();
     mock_local_data_provider_->SetPublicKey(
         base::MakeUnique<std::string>(fake_public_key));
 
     ble_advertiser_ = base::WrapUnique(new BleAdvertiser(
-        mock_adapter_, mock_eid_generator_.get(), mock_seed_fetcher_.get(),
+        mock_adapter_, base::WrapUnique(test_unregister_handler_),
+        mock_eid_generator_.get(), mock_seed_fetcher_.get(),
         mock_local_data_provider_.get()));
   }
 
   void TearDown() override {
     // Delete the advertiser to ensure that cleanup happens properly.
     ble_advertiser_.reset();
 
     // All observers should have been removed.
     EXPECT_FALSE(individual_advertisements_.size());
   }
@@ skipping 57 matching lines @@
   void ReleaseAdvertisement(
       BleAdvertiser::IndividualAdvertisement* individual_advertisement) {
     individual_advertisement->AdvertisementReleased(
         individual_advertisement->advertisement_.get());
   }
 
   std::unique_ptr<BleAdvertiser> ble_advertiser_;
 
   scoped_refptr<StrictMock<MockBluetoothAdapterWithAdvertisements>>
       mock_adapter_;
+  TestBleAdvertisementUnregisterHandler* test_unregister_handler_;
   std::unique_ptr<cryptauth::MockEidGenerator> mock_eid_generator_;
   std::unique_ptr<cryptauth::MockRemoteBeaconSeedFetcher> mock_seed_fetcher_;
   std::unique_ptr<MockLocalDeviceDataProvider> mock_local_data_provider_;
 
   std::vector<scoped_refptr<RegisterAdvertisementArgs>>
       register_advertisement_args_;
   std::vector<BleAdvertiser::IndividualAdvertisement*>
       individual_advertisements_;
 
   const std::vector<cryptauth::RemoteDevice> fake_devices_;
@@ skipping 96 matching lines @@
   EXPECT_EQ(static_cast<size_t>(1), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[0],
                            individual_advertisements_[0]);
 
   InvokeCallback(register_advertisement_args_[0]);
   VerifyAdvertisementHasStarted(individual_advertisements_[0]);
 
   // Now, unregister.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
   EXPECT_FALSE(individual_advertisements_.size());
+  EXPECT_EQ(1u, test_unregister_handler_->num_advertisements_unregistered());
 }
 
 TEST_F(BleAdvertiserTest, AdvertisementRegisteredSuccessfully_TwoDevices) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(2);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(2);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(2);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(2);
 
   // First device.
   mock_eid_generator_->set_advertisement(
@@ skipping 18 matching lines @@
   EXPECT_EQ(static_cast<size_t>(2), individual_advertisements_.size());
   EXPECT_EQ(static_cast<size_t>(2), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[1],
                            individual_advertisements_[1]);
 
   InvokeCallback(register_advertisement_args_[1]);
   VerifyAdvertisementHasStarted(individual_advertisements_[1]);
 
   // Now, unregister.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
+  EXPECT_EQ(1u, test_unregister_handler_->num_advertisements_unregistered());
+
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[1]));
+  EXPECT_EQ(2u, test_unregister_handler_->num_advertisements_unregistered());
+
   EXPECT_FALSE(individual_advertisements_.size());
 }
 
 TEST_F(BleAdvertiserTest, TooManyDevicesRegistered) {
   ASSERT_EQ(2, kMaxConcurrentAdvertisements);
 
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(3);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(3);
   EXPECT_CALL(*mock_adapter_, IsPowered()).Times(3);
   EXPECT_CALL(*mock_adapter_, RegisterAdvertisementWithArgsStruct(_)).Times(3);
 
   mock_eid_generator_->set_advertisement(
       base::MakeUnique<cryptauth::EidGenerator::DataWithTimestamp>(
           fake_advertisements_[0]));
 
   // Should succeed for the first two devices.
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[0]));
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[1]));
 
   // Should fail on the third device.
   EXPECT_FALSE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[2]));
 
-  // Now, unregister one; registering the third device should succeed at this
-  // point.
+  // Now, stop advertising to one; registering the third device should succeed
+  // at this point.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
+
+  // Because the advertisement was never registered to begin with, it also
+  // should never have been unregistered.
+  EXPECT_EQ(0u, test_unregister_handler_->num_advertisements_unregistered());
+
   EXPECT_TRUE(ble_advertiser_->StartAdvertisingToDevice(fake_devices_[2]));
 }
 
 TEST_F(BleAdvertiserTest, AdapterPowerChange_StartsOffThenTurnsOn) {
   EXPECT_CALL(*mock_adapter_, AddObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, RemoveObserver(_)).Times(1);
   EXPECT_CALL(*mock_adapter_, IsPowered())
       .Times(2)
       .WillOnce(Return(false))  // First, the adapter is powered off.
       .WillOnce(Return(true));  // Then, the adapter is powered back on.
@@ skipping 43 matching lines @@
   ReleaseAdvertisement(individual_advertisements_[0]);
   EXPECT_EQ(static_cast<size_t>(2), register_advertisement_args_.size());
   VerifyServiceDataMatches(register_advertisement_args_[1],
                            individual_advertisements_[0]);
 
   InvokeCallback(register_advertisement_args_[1]);
   VerifyAdvertisementHasStarted(individual_advertisements_[0]);
 
   // Now, unregister.
   EXPECT_TRUE(ble_advertiser_->StopAdvertisingToDevice(fake_devices_[0]));
+  EXPECT_EQ(1u, test_unregister_handler_->num_advertisements_unregistered());
   EXPECT_FALSE(individual_advertisements_.size());
 }
 
 }  // namespace tether
 
 }  // namespace cryptauth