Refactor SignalStrategy so that it can be reused for multiple connections.

remoting/protocol/connection_to_host.cc

 // Copyright (c) 2011 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 "remoting/protocol/connection_to_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
@@ skipping 53 matching lines @@
   access_code_ = access_code;
 
   // Save jid of the host. The actual connection is created later after
   // |signal_strategy_| is connected.
   host_jid_ = host_jid;
   host_public_key_ = host_public_key;
 
   JavascriptSignalStrategy* strategy = new JavascriptSignalStrategy(your_jid);
   strategy->AttachXmppProxy(xmpp_proxy);
   signal_strategy_.reset(strategy);
-  signal_strategy_->Init(this);
+  signal_strategy_->AddListener(this);
+  signal_strategy_->Connect();
+
+  session_manager_.reset(new PepperSessionManager(pp_instance_));
+  session_manager_->Init(signal_strategy_.get(), this, allow_nat_traversal_);
 }
 
 void ConnectionToHost::Disconnect(const base::Closure& shutdown_task) {
   if (!message_loop_->BelongsToCurrentThread()) {
     message_loop_->PostTask(
         FROM_HERE, base::Bind(&ConnectionToHost::Disconnect,
                               base::Unretained(this), shutdown_task));
     return;
   }
 
   CloseChannels();
 
   if (session_.get())
     session_.reset();
 
   if (session_manager_.get())
     session_manager_.reset();
 
-  if (signal_strategy_.get())
+  if (signal_strategy_.get()) {
+    signal_strategy_->RemoveListener(this);
     signal_strategy_.reset();
+  }
 
   shutdown_task.Run();
 }
 
-void ConnectionToHost::InitSession() {
-  DCHECK(message_loop_->BelongsToCurrentThread());
-
-  session_manager_.reset(new PepperSessionManager(pp_instance_));
-  session_manager_->Init(
-      local_jid_, signal_strategy_.get(), this, allow_nat_traversal_);
-}
-
 const SessionConfig& ConnectionToHost::config() {
   return session_->config();
 }
 
-void ConnectionToHost::OnStateChange(
-    SignalStrategy::StatusObserver::State state) {
+void ConnectionToHost::OnSignalStrategyStateChange(
+    SignalStrategy::State state) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(event_callback_);
 
-  if (state == SignalStrategy::StatusObserver::CONNECTED) {
-    VLOG(1) << "Connected as: " << local_jid_;
-    InitSession();
-  } else if (state == SignalStrategy::StatusObserver::CLOSED) {
+  if (state == SignalStrategy::CONNECTED) {
+    VLOG(1) << "Connected as: " << signal_strategy_->GetLocalJid();
+  } else if (state == SignalStrategy::CLOSED) {
     VLOG(1) << "Connection closed.";
     CloseOnError(NETWORK_FAILURE);
   }
 }
 
-void ConnectionToHost::OnJidChange(const std::string& full_jid) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
-  local_jid_ = full_jid;
+bool ConnectionToHost::OnSignalStrategyIncomingStanza(
+    const buzz::XmlElement* stanza) {
+  return false;
 }
 
-void ConnectionToHost::OnSessionManagerInitialized() {
+void ConnectionToHost::OnSessionManagerReady() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // After SessionManager is initialized we can try to connect to the host.
   CandidateSessionConfig* candidate_config =
       CandidateSessionConfig::CreateDefault();
   V1ClientAuthenticator* authenticator =
-      new V1ClientAuthenticator(local_jid_, access_code_);
+      new V1ClientAuthenticator(signal_strategy_->GetLocalJid(), access_code_);
   session_.reset(session_manager_->Connect(
       host_jid_, authenticator, candidate_config,
       base::Bind(&ConnectionToHost::OnSessionStateChange,
                  base::Unretained(this))));
 }
 
 void ConnectionToHost::OnIncomingSession(
     Session* session,
     SessionManager::IncomingSessionResponse* response) {
   DCHECK(message_loop_->BelongsToCurrentThread());
@@ skipping 99 matching lines @@
 
   if (state != state_) {
     state_ = state;
     error_ = error;
     event_callback_->OnConnectionState(state_, error_);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting