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

chromeos/components/tether/ble_connection_manager.h

 // 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.
 
 #ifndef CHROMEOS_COMPONENTS_TETHER_BLE_CONNECTION_MANAGER_H_
 #define CHROMEOS_COMPONENTS_TETHER_BLE_CONNECTION_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/timer/timer.h"
 #include "chromeos/components/tether/ble_advertisement_device_queue.h"
 #include "chromeos/components/tether/ble_advertiser.h"
 #include "chromeos/components/tether/ble_scanner.h"
 #include "chromeos/components/tether/proto/tether.pb.h"
 #include "components/cryptauth/remote_device.h"
 #include "components/cryptauth/secure_channel.h"
 
 namespace cryptauth {
 class BluetoothThrottler;
+class CryptAuthService;
 }  // namespace cryptauth
 
 namespace chromeos {
 
 namespace tether {
 
 // Manages connections to remote devices. When a device is registered,
 // BleConnectionManager intiates a connection to that device. If the connection
 // succeeds and authenticates successfully, messages can be sent/received
 // to/from the device. If the connection does not succeed, BleConnectionManager
@@ skipping 23 matching lines @@
    public:
     virtual void OnSecureChannelStatusChanged(
         const cryptauth::RemoteDevice& remote_device,
         const cryptauth::SecureChannel::Status& old_status,
         const cryptauth::SecureChannel::Status& new_status) = 0;
 
     virtual void OnMessageReceived(const cryptauth::RemoteDevice& remote_device,
                                    const std::string& payload) = 0;
   };
 
-  class Delegate {
-   public:
-    virtual std::unique_ptr<cryptauth::SecureChannel::Delegate>
-    CreateSecureChannelDelegate() = 0;
-  };
-
   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);
   virtual ~BleConnectionManager();
 
   // Registers |remote_device| for |connection_reason|. Once registered, this
   // instance will continue to attempt to connect and authenticate to that
   // device until the device is unregistered.
   virtual void RegisterRemoteDevice(
@@ skipping 87 matching lines @@
 
     base::WeakPtrFactory<ConnectionMetadata> weak_ptr_factory_;
   };
 
   class TimerFactory {
    public:
     virtual std::unique_ptr<base::Timer> CreateTimer();
   };
 
   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);
 
   std::shared_ptr<ConnectionMetadata> GetConnectionMetadata(
       const cryptauth::RemoteDevice& remote_device) const;
   std::shared_ptr<ConnectionMetadata> AddMetadataForDevice(
       const cryptauth::RemoteDevice& remote_device);
 
   void UpdateConnectionAttempts();
   void UpdateAdvertisementQueue();
 
   void StartConnectionAttempt(const cryptauth::RemoteDevice& remote_device);
   void StopConnectionAttemptAndMoveToEndOfQueue(
       const cryptauth::RemoteDevice& remote_device);
 
   void OnConnectionAttemptTimeout(const cryptauth::RemoteDevice& remote_device);
   void OnSecureChannelStatusChanged(
       const cryptauth::RemoteDevice& remote_device,
       const cryptauth::SecureChannel::Status& old_status,
       const cryptauth::SecureChannel::Status& new_status);
 
-  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_;
 
   bool has_registered_observer_;
   std::map<cryptauth::RemoteDevice, std::shared_ptr<ConnectionMetadata>>
       device_to_metadata_map_;
 
   base::ObserverList<Observer> observer_list_;
   base::WeakPtrFactory<BleConnectionManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BleConnectionManager);
 };
 
 }  // namespace tether
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_COMPONENTS_TETHER_BLE_CONNECTION_MANAGER_H_