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

components/cryptauth/secure_channel.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 COMPONENTS_CRYPTAUTH_SECURE_CHANNEL_H_
 #define COMPONENTS_CRYPTAUTH_SECURE_CHANNEL_H_
 
 #include <deque>
 
 #include "base/macros.h"
@@ skipping 49 matching lines @@
   };
 
   class Delegate {
    public:
     virtual ~Delegate();
 
     virtual std::unique_ptr<SecureMessageDelegate>
     CreateSecureMessageDelegate() = 0;
   };
 
-  SecureChannel(
-      std::unique_ptr<Connection> connection,
-      std::unique_ptr<Delegate> delegate);
+  class Factory {
+   public:
+    static std::unique_ptr<SecureChannel> NewInstance(
+        std::unique_ptr<Connection> connection,
+        std::unique_ptr<Delegate> delegate);
+
+    static void SetInstanceForTesting(Factory* factory);
+
+   protected:
+    virtual std::unique_ptr<SecureChannel> BuildInstance(
+        std::unique_ptr<Connection> connection,
+        std::unique_ptr<Delegate> delegate);
+
+   private:
+    static Factory* factory_instance_;
+  };
+
   ~SecureChannel() override;
 
-  void Initialize();
+  virtual void Initialize();
 
-  void SendMessage(const std::string& feature, const std::string& payload);
+  virtual void SendMessage(const std::string& feature,
+                           const std::string& payload);
 
-  void Disconnect();
+  virtual void Disconnect();
 
-  void AddObserver(Observer* observer);
-  void RemoveObserver(Observer* observer);
+  virtual void AddObserver(Observer* observer);
+  virtual void RemoveObserver(Observer* observer);
 
   Status status() const {
     return status_;
   }
 
   // ConnectionObserver:
   void OnConnectionStatusChanged(Connection* connection,
                                  Connection::Status old_status,
                                  Connection::Status new_status) override;
   void OnMessageReceived(const Connection& connection,
                          const WireMessage& wire_message) override;
   void OnSendCompleted(const cryptauth::Connection& connection,
                        const cryptauth::WireMessage& wire_message,
                        bool success) override;
 
+ protected:
+  SecureChannel(std::unique_ptr<Connection> connection,
+                std::unique_ptr<Delegate> delegate);
+
+  Status status_;
+
  private:
   // Message waiting to be sent. Note that this is *not* the message that will
   // end up being sent over the wire; before that can be done, the payload must
   // be encrypted.
   struct PendingMessage {
     PendingMessage();
     PendingMessage(const std::string& feature, const std::string& payload);
     virtual ~PendingMessage();
 
     const std::string feature;
     const std::string payload;
   };
 
   void TransitionToStatus(const Status& new_status);
   void Authenticate();
   void ProcessMessageQueue();
   void OnMessageEncoded(
       const std::string& feature, const std::string& encoded_message);
   void OnMessageDecoded(
       const std::string& feature, const std::string& decoded_message);
   void OnAuthenticationResult(
       Authenticator::Result result,
       std::unique_ptr<SecureContext> secure_context);
 
   std::unique_ptr<Connection> connection_;
   std::unique_ptr<Delegate> delegate_;
   std::unique_ptr<Authenticator> authenticator_;
   std::unique_ptr<SecureContext> secure_context_;
-  Status status_;
   std::deque<PendingMessage> queued_messages_;
   std::unique_ptr<PendingMessage> pending_message_;
   base::ObserverList<Observer> observer_list_;
   base::WeakPtrFactory<SecureChannel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(SecureChannel);
 };
 
 }  // namespace cryptauth
 
 #endif  // COMPONENTS_CRYPTAUTH_SECURE_CHANNEL_H_