[CrOS Tether]: Create BleConnectionManager, which manages secure connections between the current de…

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"
@@ skipping 101 matching lines @@
  private:
   Authenticator* last_instance_;
 };
 
 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)) {}
+};
+
 }  // 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_connection_ =
         new FakeConnection(test_device_, /* should_auto_connect */ false);
 
     EXPECT_FALSE(fake_connection_->observers().size());
-    secure_channel_ = base::MakeUnique<SecureChannel>(
+    secure_channel_ = base::MakeUnique<TestSecureChannel>(
         base::WrapUnique(fake_connection_), base::WrapUnique(test_delegate_));
     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
@@ skipping 382 matching lines @@
 
   StartAndFinishSendingMessage("feature", "request2", /* success */ true);
 
   fake_connection_->ReceiveMessage("feature", "response2, but encoded");
   VerifyReceivedMessages(std::vector<ReceivedMessage> {
       {"feature", "response2"}
   });
 }
 
 }  // namespace cryptauth