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

chromeos/components/tether/ble_connection_manager_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_connection_manager.h"
 
 #include "base/logging.h"
 #include "base/timer/mock_timer.h"
 #include "chromeos/components/tether/ble_constants.h"
 #include "chromeos/components/tether/proto/tether.pb.h"
 #include "components/cryptauth/ble/bluetooth_low_energy_weave_client_connection.h"
 #include "components/cryptauth/bluetooth_throttler.h"
 #include "components/cryptauth/connection.h"
 #include "components/cryptauth/fake_connection.h"
+#include "components/cryptauth/fake_cryptauth_service.h"
 #include "components/cryptauth/fake_secure_channel.h"
 #include "components/cryptauth/fake_secure_message_delegate.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::NiceMock;
 using testing::Return;
 
 namespace chromeos {
 
 namespace tether {
 
 namespace {
 
 const char kTetherFeature[] = "magic_tether";
 
 const char kUserId[] = "userId";
 
 const char kBluetoothAddress1[] = "11:22:33:44:55:66";
 const char kBluetoothAddress2[] = "22:33:44:55:66:77";
 const char kBluetoothAddress3[] = "33:44:55:66:77:88";
 
-class FakeSecureChannelDelegate : public cryptauth::SecureChannel::Delegate {
- public:
-  FakeSecureChannelDelegate() {}
-  ~FakeSecureChannelDelegate() override {}
-
-  std::unique_ptr<cryptauth::SecureMessageDelegate>
-  CreateSecureMessageDelegate() override {
-    return base::MakeUnique<cryptauth::FakeSecureMessageDelegate>();
-  }
-};
-
-class TestDelegate : public BleConnectionManager::Delegate {
- public:
-  TestDelegate() {}
-  ~TestDelegate() {}
-
-  std::unique_ptr<cryptauth::SecureChannel::Delegate>
-  CreateSecureChannelDelegate() override {
-    return base::WrapUnique(new FakeSecureChannelDelegate());
-  }
-};
-
 struct SecureChannelStatusChange {
   SecureChannelStatusChange(const cryptauth::RemoteDevice& remote_device,
                             const cryptauth::SecureChannel::Status& old_status,
                             const cryptauth::SecureChannel::Status& new_status)
       : remote_device(remote_device),
         old_status(old_status),
         new_status(new_status) {}
 
   cryptauth::RemoteDevice remote_device;
   cryptauth::SecureChannel::Status old_status;
@@ skipping 130 matching lines @@
   }
   return test_devices;
 }
 
 }  // namespace
 
 class BleConnectionManagerTest : public testing::Test {
  protected:
   class FakeSecureChannel : public cryptauth::FakeSecureChannel {
    public:
-    FakeSecureChannel(
-        std::unique_ptr<cryptauth::Connection> connection,
-        std::unique_ptr<cryptauth::SecureChannel::Delegate> delegate)
+    FakeSecureChannel(std::unique_ptr<cryptauth::Connection> connection,
+                      cryptauth::CryptAuthService* cryptauth_service)
         : cryptauth::FakeSecureChannel(std::move(connection),
-                                       std::move(delegate)) {}
+                                       cryptauth_service) {}
     ~FakeSecureChannel() override {}
 
     void AddObserver(Observer* observer) override {
       cryptauth::FakeSecureChannel::AddObserver(observer);
 
       EXPECT_EQ(static_cast<size_t>(1), observers().size());
     }
 
     void RemoveObserver(Observer* observer) override {
       cryptauth::FakeSecureChannel::RemoveObserver(observer);
       EXPECT_EQ(static_cast<size_t>(0), observers().size());
     }
   };
 
   class FakeSecureChannelFactory : public cryptauth::SecureChannel::Factory {
    public:
     FakeSecureChannelFactory() {}
 
     void SetExpectedDeviceAddress(const std::string& expected_device_address) {
       expected_device_address_ = expected_device_address;
     }
 
     std::unique_ptr<cryptauth::SecureChannel> BuildInstance(
         std::unique_ptr<cryptauth::Connection> connection,
-        std::unique_ptr<cryptauth::SecureChannel::Delegate> delegate) override {
+        cryptauth::CryptAuthService* cryptauth_service) override {
       FakeConnectionWithAddress* fake_connection =
           static_cast<FakeConnectionWithAddress*>(connection.get());
       EXPECT_EQ(expected_device_address_, fake_connection->GetDeviceAddress());
       return base::WrapUnique(
-          new FakeSecureChannel(std::move(connection), std::move(delegate)));
+          new FakeSecureChannel(std::move(connection), cryptauth_service));
     }
 
    private:
     std::string expected_device_address_;
   };
 
   class MockTimerFactory : public BleConnectionManager::TimerFactory {
    public:
     std::unique_ptr<base::Timer> CreateTimer() override {
       return base::MakeUnique<base::MockTimer>(false /* retains_user_task */,
                                                false /* is_repeating */);
     }
   };
 
   BleConnectionManagerTest() : test_devices_(CreateTestDevices(4)) {
     // These tests assume a maximum of two concurrent advertisers. Some of the
     // multi-device tests would need to be re-written if this constant changes.
     EXPECT_EQ(2, kMaxConcurrentAdvertisements);
   }
 
   void SetUp() override {
     verified_status_changes_.clear();
     verified_received_messages_.clear();
 
-    delegate_ = new TestDelegate();
+    fake_cryptauth_service_ =
+        base::MakeUnique<cryptauth::FakeCryptAuthService>();
     mock_adapter_ =
         make_scoped_refptr(new NiceMock<device::MockBluetoothAdapter>());
 
     mock_ble_scanner_ = new MockBleScanner();
     ON_CALL(*mock_ble_scanner_, RegisterScanFilterForDevice(_))
         .WillByDefault(Return(true));
     ON_CALL(*mock_ble_scanner_, UnregisterScanFilterForDevice(_))
         .WillByDefault(Return(true));
 
     mock_ble_advertiser_ = new MockBleAdvertiser();
@@ skipping 11 matching lines @@
         mock_bluetooth_throttler_.get()));
     cryptauth::weave::BluetoothLowEnergyWeaveClientConnection::Factory::
         SetInstanceForTesting(std::move(fake_connection_factory_));
 
     fake_secure_channel_factory_ =
         base::WrapUnique(new FakeSecureChannelFactory());
     cryptauth::SecureChannel::Factory::SetInstanceForTesting(
         fake_secure_channel_factory_.get());
 
     manager_ = base::WrapUnique(new BleConnectionManager(
-        base::WrapUnique(delegate_), mock_adapter_,
+        fake_cryptauth_service_.get(), mock_adapter_,
         base::WrapUnique(mock_ble_scanner_),
         base::WrapUnique(mock_ble_advertiser_), base::WrapUnique(device_queue_),
         base::WrapUnique(mock_timer_factory_),
         mock_bluetooth_throttler_.get()));
     test_observer_ = base::WrapUnique(new TestObserver());
     manager_->AddObserver(test_observer_.get());
   }
 
   void TearDown() override {
     // All state changes should have already been verified. This ensures that
@@ skipping 162 matching lines @@
                              size_t expected_size) {
     ASSERT_EQ(expected_size, channel->sent_messages().size());
     cryptauth::FakeSecureChannel::SentMessage sent_message =
         channel->sent_messages()[expected_size - 1];
     EXPECT_EQ(std::string(kTetherFeature), sent_message.feature);
     EXPECT_EQ(payload, sent_message.payload);
   }
 
   const std::vector<cryptauth::RemoteDevice> test_devices_;
 
-  BleConnectionManager::Delegate* delegate_;
+  std::unique_ptr<cryptauth::FakeCryptAuthService> fake_cryptauth_service_;
   scoped_refptr<NiceMock<device::MockBluetoothAdapter>> mock_adapter_;
   MockBleScanner* mock_ble_scanner_;
   MockBleAdvertiser* mock_ble_advertiser_;
   BleAdvertisementDeviceQueue* device_queue_;
   MockTimerFactory* mock_timer_factory_;
   std::unique_ptr<MockBluetoothThrottler> mock_bluetooth_throttler_;
   std::unique_ptr<FakeConnectionFactory> fake_connection_factory_;
   std::unique_ptr<FakeSecureChannelFactory> fake_secure_channel_factory_;
   std::unique_ptr<TestObserver> test_observer_;
 
@@ skipping 697 matching lines @@
        cryptauth::SecureChannel::Status::DISCONNECTED},
       {test_devices_[1], cryptauth::SecureChannel::Status::CONNECTING,
        cryptauth::SecureChannel::Status::DISCONNECTED},
       {test_devices_[2], cryptauth::SecureChannel::Status::CONNECTING,
        cryptauth::SecureChannel::Status::DISCONNECTED}});
 }
 
 }  // namespace tether
 
 }  // namespace cryptauth