Tether: Break helper TimerFactory out of BleConnectionManager and HostScanCache.

chromeos/components/tether/ble_connection_manager.cc

 // Copyright 2017 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_connection_manager.h"
 
 #include "chromeos/components/tether/ble_constants.h"
+#include "chromeos/components/tether/timer_factory.h"
 #include "components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h"
 #include "components/cryptauth/cryptauth_service.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
@@ skipping 140 matching lines @@
     const std::string& payload) {
   DCHECK(secure_channel_.get() == secure_channel);
   if (feature != std::string(kTetherFeature)) {
     // If the message received was not a tether feature, ignore it.
     return;
   }
 
   manager_->SendMessageReceivedEvent(remote_device_, payload);
 }
 
-std::unique_ptr<base::Timer> BleConnectionManager::TimerFactory::CreateTimer() {
-  return base::MakeUnique<base::OneShotTimer>();
-}
-
 BleConnectionManager::BleConnectionManager(
     cryptauth::CryptAuthService* cryptauth_service,
     scoped_refptr<device::BluetoothAdapter> adapter,
     const LocalDeviceDataProvider* local_device_data_provider,
     const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher,
     cryptauth::BluetoothThrottler* bluetooth_throttler)
     : BleConnectionManager(
           cryptauth_service,
           adapter,
           base::MakeUnique<BleScanner>(adapter, local_device_data_provider),
           base::MakeUnique<BleAdvertiser>(adapter,
                                           local_device_data_provider,
                                           remote_beacon_seed_fetcher),
           base::MakeUnique<BleAdvertisementDeviceQueue>(),
-          base::WrapUnique<TimerFactory>(new TimerFactory()),
+          base::MakeUnique<TimerFactory>(),
           bluetooth_throttler) {}
 
 BleConnectionManager::BleConnectionManager(
     cryptauth::CryptAuthService* cryptauth_service,
     scoped_refptr<device::BluetoothAdapter> adapter,
     std::unique_ptr<BleScanner> ble_scanner,
     std::unique_ptr<BleAdvertiser> ble_advertiser,
     std::unique_ptr<BleAdvertisementDeviceQueue> device_queue,
     std::unique_ptr<TimerFactory> timer_factory,
     cryptauth::BluetoothThrottler* bluetooth_throttler)
@@ skipping 168 matching lines @@
 
 std::shared_ptr<BleConnectionManager::ConnectionMetadata>
 BleConnectionManager::AddMetadataForDevice(
     const cryptauth::RemoteDevice& remote_device) {
   std::shared_ptr<ConnectionMetadata> existing_data =
       GetConnectionMetadata(remote_device);
   if (existing_data) {
     return existing_data;
   }
 
-  std::unique_ptr<base::Timer> timer = timer_factory_->CreateTimer();
+  std::unique_ptr<base::Timer> timer = timer_factory_->CreateOneShotTimer();
   device_to_metadata_map_.insert(
       std::pair<cryptauth::RemoteDevice, std::shared_ptr<ConnectionMetadata>>(
           remote_device,
           std::shared_ptr<ConnectionMetadata>(
               new ConnectionMetadata(remote_device, std::move(timer),
                                      weak_ptr_factory_.GetWeakPtr()))));
   return device_to_metadata_map_.at(remote_device);
 }
 
 void BleConnectionManager::UpdateConnectionAttempts() {
@@ skipping 117 matching lines @@
                << cryptauth::SecureChannel::StatusToString(new_status);
   for (auto& observer : observer_list_) {
     observer.OnSecureChannelStatusChanged(remote_device, old_status,
                                           new_status);
   }
 }
 
 }  // namespace tether
 
 }  // namespace chromeos