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

chromeos/components/tether/ble_advertiser.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/bind.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/local_device_data_provider.h"
 #include "components/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/cryptauth/remote_beacon_seed_fetcher.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 uint8_t kInvertedConnectionFlag = 0x01;
 }  // namespace
 
+void BleAdvertiser::BleAdvertisementUnregisterHandlerImpl::
+    OnAdvertisementUnregisterSuccess() {}
+
+void BleAdvertiser::BleAdvertisementUnregisterHandlerImpl::
+    OnAdvertisementUnregisterFailure(
+        device::BluetoothAdvertisement::ErrorCode error_code) {
+  PA_LOG(ERROR) << "Error while unregistering advertisement. Error code: "
+                << error_code;
+}
+
 BleAdvertiser::IndividualAdvertisement::IndividualAdvertisement(
     scoped_refptr<device::BluetoothAdapter> adapter,
     std::unique_ptr<cryptauth::EidGenerator::DataWithTimestamp>
-        advertisement_data)
+        advertisement_data,
+    std::shared_ptr<BleAdvertisementUnregisterHandler> unregister_handler)
     : adapter_(adapter),
       is_initializing_advertising_(false),
       advertisement_data_(std::move(advertisement_data)),
+      unregister_handler_(unregister_handler),
       advertisement_(nullptr),
       weak_ptr_factory_(this) {
   adapter_->AddObserver(this);
   AdvertiseIfPossible();
 }
 
 BleAdvertiser::IndividualAdvertisement::~IndividualAdvertisement() {
+  if (advertisement_) {
+    advertisement_->Unregister(
+        base::Bind(&BleAdvertisementUnregisterHandler::
+                       OnAdvertisementUnregisterSuccess,
+                   base::Unretained(unregister_handler_.get())),
+        base::Bind(&BleAdvertisementUnregisterHandler::
+                       OnAdvertisementUnregisterFailure,
+                   base::Unretained(unregister_handler_.get())));
+  }
+
   adapter_->RemoveObserver(this);
 }
 
 void BleAdvertiser::IndividualAdvertisement::AdapterPoweredChanged(
     device::BluetoothAdapter* adapter,
     bool powered) {
   DCHECK(adapter_.get() == adapter);
   AdvertiseIfPossible();
 }
 
@@ skipping 81 matching lines @@
     ss << static_cast<int>(advertisement_data_->data.data()[i]);
   }
 
   return ss.str();
 }
 
 BleAdvertiser::BleAdvertiser(
     scoped_refptr<device::BluetoothAdapter> adapter,
     const LocalDeviceDataProvider* local_device_data_provider,
     const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher)
-    : BleAdvertiser(adapter,
-                    cryptauth::EidGenerator::GetInstance(),
-                    remote_beacon_seed_fetcher,
-                    local_device_data_provider) {}
+    : BleAdvertiser(
+          adapter,
+          base::WrapUnique(new BleAdvertisementUnregisterHandlerImpl()),
+          cryptauth::EidGenerator::GetInstance(),
+          remote_beacon_seed_fetcher,
+          local_device_data_provider) {}
 
 BleAdvertiser::~BleAdvertiser() {}
 
 BleAdvertiser::BleAdvertiser(
     scoped_refptr<device::BluetoothAdapter> adapter,
+    std::unique_ptr<BleAdvertisementUnregisterHandler> unregister_handler,
     const cryptauth::EidGenerator* eid_generator,
     const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
     const LocalDeviceDataProvider* local_device_data_provider)
     : adapter_(adapter),
+      unregister_handler_(std::move(unregister_handler)),
       eid_generator_(eid_generator),
       remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher),
       local_device_data_provider_(local_device_data_provider) {}
 
 bool BleAdvertiser::StartAdvertisingToDevice(
     const cryptauth::RemoteDevice& remote_device) {
   if (device_id_to_advertisement_map_.size() >= kMaxConcurrentAdvertisements) {
     PA_LOG(ERROR) << "Attempted to register a device when the maximum number "
                   << "of devices have already been registered.";
     return false;
@@ skipping 29 matching lines @@
       eid_generator_->GenerateAdvertisement(local_device_public_key,
                                             remote_beacon_seeds);
   if (!advertisement) {
     PA_LOG(WARNING) << "Error generating advertisement for device with ID "
                     << remote_device.GetTruncatedDeviceIdForLogs() << ". "
                     << "Cannot advertise.";
     return false;
   }
 
   device_id_to_advertisement_map_[remote_device.GetDeviceId()] =
-      make_scoped_refptr(
-          new IndividualAdvertisement(adapter_, std::move(advertisement)));
+      make_scoped_refptr(new IndividualAdvertisement(
+          adapter_, std::move(advertisement), unregister_handler_));
   return true;
 }
 
 bool BleAdvertiser::StopAdvertisingToDevice(
     const cryptauth::RemoteDevice& remote_device) {
   return device_id_to_advertisement_map_.erase(remote_device.GetDeviceId()) > 0;
 }
 
 }  // namespace tether
 
 }  // namespace chromeos