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

components/cryptauth/secure_channel.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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/cryptauth/wire_message.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace cryptauth {
 
 // static
+SecureChannel::Factory* SecureChannel::Factory::factory_instance_ = nullptr;
+
+// static
+std::unique_ptr<SecureChannel> SecureChannel::Factory::NewInstance(
+    std::unique_ptr<Connection> connection,
+    std::unique_ptr<Delegate> delegate) {
+  if (!factory_instance_) {
+    factory_instance_ = new Factory();
+  }
+  return factory_instance_->BuildInstance(std::move(connection),
+                                          std::move(delegate));
+}
+
+// static
+void SecureChannel::Factory::SetInstanceForTesting(Factory* factory) {
+  factory_instance_ = factory;
+}
+
+std::unique_ptr<SecureChannel> SecureChannel::Factory::BuildInstance(
+    std::unique_ptr<Connection> connection,
+    std::unique_ptr<Delegate> delegate) {
+  return base::WrapUnique(
+      new SecureChannel(std::move(connection), std::move(delegate)));
+}
+
+// static
 std::string SecureChannel::StatusToString(const Status& status) {
   switch (status) {
     case Status::DISCONNECTED:
       return "[disconnected]";
     case Status::CONNECTING:
       return "[connecting]";
     case Status::CONNECTED:
       return "[connected]";
     case Status::AUTHENTICATING:
       return "[authenticating]";
     case Status::AUTHENTICATED:
       return "[authenticated]";
     default:
       return "[unknown status]";
   }
 }
 
 SecureChannel::Delegate::~Delegate() {}
 
 SecureChannel::PendingMessage::PendingMessage() {}
 
 SecureChannel::PendingMessage::PendingMessage(
     const std::string& feature, const std::string& payload)
     : feature(feature), payload(payload) {}
 
 SecureChannel::PendingMessage::~PendingMessage() {}
 
-SecureChannel::SecureChannel(
-    std::unique_ptr<Connection> connection,
-    std::unique_ptr<Delegate> delegate)
-    : connection_(std::move(connection)),
+SecureChannel::SecureChannel(std::unique_ptr<Connection> connection,
+                             std::unique_ptr<Delegate> delegate)
+    : status_(Status::DISCONNECTED),
+      connection_(std::move(connection)),
       delegate_(std::move(delegate)),
-      status_(Status::DISCONNECTED),
       weak_ptr_factory_(this) {
   DCHECK(connection_);
   DCHECK(!connection_->IsConnected());
   DCHECK(!connection_->remote_device().user_id.empty());
   DCHECK(delegate_);
 
   connection_->AddObserver(this);
 }
 
 SecureChannel::~SecureChannel() {
@@ skipping 180 matching lines @@
         << connection_->remote_device().GetTruncatedDeviceIdForLogs();
     Disconnect();
     return;
   }
 
   secure_context_ = std::move(secure_context);
   TransitionToStatus(Status::AUTHENTICATED);
 }
 
 }  // namespace cryptauth