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

components/cryptauth/secure_channel_unittest.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 "components/cryptauth/secure_channel.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "components/cryptauth/fake_authenticator.h"
 #include "components/cryptauth/fake_connection.h"
+#include "components/cryptauth/fake_cryptauth_service.h"
 #include "components/cryptauth/fake_secure_context.h"
 #include "components/cryptauth/fake_secure_message_delegate.h"
 #include "components/cryptauth/remote_device_test_util.h"
 #include "components/cryptauth/wire_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cryptauth {
 
 namespace {
 
 const std::string test_user_id = "testUserId";
 
-class TestDelegate : public SecureChannel::Delegate {
- public:
-  TestDelegate(std::unique_ptr<SecureMessageDelegate> secure_message_delegate)
-      : secure_message_delegate_(std::move(secure_message_delegate)) {}
-  ~TestDelegate() override {}
-
-  std::unique_ptr<SecureMessageDelegate> CreateSecureMessageDelegate()
-      override {
-    return std::move(secure_message_delegate_);
-  }
-
- private:
-  std::unique_ptr<SecureMessageDelegate> secure_message_delegate_;
-};
-
 struct SecureChannelStatusChange {
   SecureChannelStatusChange(
       const SecureChannel::Status& old_status,
       const SecureChannel::Status& new_status)
       : old_status(old_status), new_status(new_status) {}
 
   SecureChannel::Status old_status;
   SecureChannel::Status new_status;
 };
 
@@ skipping 64 matching lines @@
 
 RemoteDevice CreateTestRemoteDevice() {
   RemoteDevice remote_device = GenerateTestRemoteDevices(1)[0];
   remote_device.user_id = test_user_id;
   return remote_device;
 }
 
 class TestSecureChannel : public SecureChannel {
  public:
   TestSecureChannel(std::unique_ptr<Connection> connection,
-                    std::unique_ptr<Delegate> delegate)
-      : SecureChannel(std::move(connection), std::move(delegate)) {}
+                    CryptAuthService* cryptauth_service)
+      : SecureChannel(std::move(connection), cryptauth_service) {}
 };
 
 }  // namespace
 
 class CryptAuthSecureChannelTest : public testing::Test {
  protected:
   CryptAuthSecureChannelTest()
       : test_device_(CreateTestRemoteDevice()),
         weak_ptr_factory_(this) {}
 
   void SetUp() override {
     test_authenticator_factory_ = base::MakeUnique<TestAuthenticatorFactory>();
     DeviceToDeviceAuthenticator::Factory::SetInstanceForTesting(
         test_authenticator_factory_.get());
 
     fake_secure_context_ = nullptr;
 
-    fake_secure_message_delegate_ = new FakeSecureMessageDelegate();
-
-    test_delegate_ =
-        new TestDelegate(base::WrapUnique(fake_secure_message_delegate_));
+    fake_cryptauth_service_ = base::MakeUnique<FakeCryptAuthService>();
 
     fake_connection_ =
         new FakeConnection(test_device_, /* should_auto_connect */ false);
 
     EXPECT_FALSE(fake_connection_->observers().size());
     secure_channel_ = base::MakeUnique<TestSecureChannel>(
-        base::WrapUnique(fake_connection_), base::WrapUnique(test_delegate_));
+        base::WrapUnique(fake_connection_), fake_cryptauth_service_.get());
     EXPECT_EQ(static_cast<size_t>(1), fake_connection_->observers().size());
     EXPECT_EQ(secure_channel_.get(), fake_connection_->observers()[0]);
 
     test_observer_ = base::MakeUnique<TestObserver>(secure_channel_.get());
     secure_channel_->AddObserver(test_observer_.get());
   }
 
   void TearDown() override {
     // All state changes should have already been verified. This ensures that
     // no test has missed one.
@@ skipping 128 matching lines @@
       WireMessage* wire_message,
       const std::string& expected_feature,
       const std::string& expected_payload) {
     EXPECT_EQ(expected_feature, wire_message->feature());
     EXPECT_EQ(expected_payload, wire_message->payload());
   }
 
   // Owned by secure_channel_.
   FakeConnection* fake_connection_;
 
-  // Owned by secure_chanel_.
-  TestDelegate* test_delegate_;
-
-  // Owned by test_delegate_.
-  FakeSecureMessageDelegate* fake_secure_message_delegate_;
+  std::unique_ptr<FakeCryptAuthService> fake_cryptauth_service_;
 
   // Owned by secure_channel_ once authentication has completed successfully.
   FakeSecureContext* fake_secure_context_;
 
   std::vector<SecureChannelStatusChange> verified_status_changes_;
 
   std::vector<ReceivedMessage> verified_received_messages_;
 
   std::unique_ptr<SecureChannel> secure_channel_;
 
@@ skipping 228 matching lines @@
 
   StartAndFinishSendingMessage("feature", "request2", /* success */ true);
 
   fake_connection_->ReceiveMessage("feature", "response2, but encoded");
   VerifyReceivedMessages(std::vector<ReceivedMessage> {
       {"feature", "response2"}
   });
 }
 
 }  // namespace cryptauth