[CrOS Tether] Update SecureChannel and BleConnectionManager to use CryptAuthService instead of a Del

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 "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 {
 const char kTetherFeature[] = "magic_tether";
 }  // namespace
@@ skipping 139 matching lines @@
   }
 
   manager_->SendMessageReceivedEvent(remote_device_, payload);
 }
 
 std::unique_ptr<base::Timer> BleConnectionManager::TimerFactory::CreateTimer() {
   return base::MakeUnique<base::OneShotTimer>();
 }
 
 BleConnectionManager::BleConnectionManager(
-    std::unique_ptr<Delegate> delegate,
+    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(
-          std::move(delegate),
+          cryptauth_service,
           adapter,
           // TODO(khorimoto): Inject |adapter| into |BleScanner|.
           base::MakeUnique<BleScanner>(local_device_data_provider),
           base::MakeUnique<BleAdvertiser>(adapter,
                                           local_device_data_provider,
                                           remote_beacon_seed_fetcher),
           base::MakeUnique<BleAdvertisementDeviceQueue>(),
           base::WrapUnique<TimerFactory>(new TimerFactory()),
           bluetooth_throttler) {}
 
 BleConnectionManager::BleConnectionManager(
-    std::unique_ptr<Delegate> delegate,
+    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)
-    : delegate_(std::move(delegate)),
+    : cryptauth_service_(cryptauth_service),
       adapter_(adapter),
       ble_scanner_(std::move(ble_scanner)),
       ble_advertiser_(std::move(ble_advertiser)),
       device_queue_(std::move(device_queue)),
       timer_factory_(std::move(timer_factory)),
       bluetooth_throttler_(bluetooth_throttler),
       has_registered_observer_(false),
       weak_ptr_factory_(this) {}
 
 BleConnectionManager::~BleConnectionManager() {
@@ skipping 118 matching lines @@
                << remote_device.GetTruncatedDeviceIdForLogs() << ". "
                << "Starting authentication handshake to that device.";
 
   // Create a connection to that device.
   std::unique_ptr<cryptauth::Connection> connection =
       cryptauth::weave::BluetoothLowEnergyWeaveClientConnection::Factory::
           NewInstance(remote_device, device_address, adapter_,
                       device::BluetoothUUID(std::string(kGattServerUuid)),
                       bluetooth_throttler_);
   std::unique_ptr<cryptauth::SecureChannel> secure_channel =
-      cryptauth::SecureChannel::Factory::NewInstance(
-          std::move(connection), delegate_->CreateSecureChannelDelegate());
+      cryptauth::SecureChannel::Factory::NewInstance(std::move(connection),
+                                                     cryptauth_service_);
   connection_metadata->SetSecureChannel(std::move(secure_channel));
 
   // Stop trying to connect to that device, since a connection already exists.
   StopConnectionAttemptAndMoveToEndOfQueue(remote_device);
   UpdateConnectionAttempts();
 }
 
 std::shared_ptr<BleConnectionManager::ConnectionMetadata>
 BleConnectionManager::GetConnectionMetadata(
     const cryptauth::RemoteDevice& remote_device) const {
@@ skipping 145 matching lines @@
                << cryptauth::SecureChannel::StatusToString(new_status);
   for (auto& observer : observer_list_) {
     observer.OnSecureChannelStatusChanged(remote_device, old_status,
                                           new_status);
   }
 }
 
 }  // namespace tether
 
 }  // namespace chromeos