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

remoting/host/chromoting_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/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
@@ skipping 75 matching lines @@
   std::string xmpp_login;
   std::string xmpp_auth_token;
   std::string xmpp_auth_service;
   if (!config_->GetString(kXmppLoginConfigPath, &xmpp_login) ||
       !config_->GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token) ||
       !config_->GetString(kXmppAuthServiceConfigPath, &xmpp_auth_service)) {
     LOG(ERROR) << "XMPP credentials are not defined in the config.";
     return;
   }
 
+  // Create and start XMPP connection.
   signal_strategy_.reset(
       new XmppSignalStrategy(context_->jingle_thread(), xmpp_login,
-                             xmpp_auth_token,
-                             xmpp_auth_service));
-  signal_strategy_->Init(this);
+                             xmpp_auth_token, xmpp_auth_service));
+  signal_strategy_->AddListener(this);
+  signal_strategy_->Connect();
+
+  // Create and start session manager.
+  session_manager_.reset(
+      new protocol::JingleSessionManager(context_->network_message_loop()));
+  session_manager_->Init(signal_strategy_.get(),
+                         this, allow_nat_traversal_);

[Wez, 2011/12/21 23:35:30]

nit: We should replace Init() with an AcceptConnections() method on
SessionManager.

[Sergey Ulanov, 2011/12/22 21:45:10]

Init() must be called before Connect() even if we don't need to accept incoming
connections, so I think Init() is the right name for this method.

 }
 
 // This method is called when we need to destroy the host process.
 void ChromotingHost::Shutdown(const base::Closure& shutdown_task) {
   if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::Shutdown, this, shutdown_task));
     return;
   }
 
@@ skipping 22 matching lines @@
     // this method may be invoked in response to a libjingle event and
     // libjingle's sigslot doesn't handle it properly, so postpone the
     // deletion.
     context_->network_message_loop()->DeleteSoon(
         FROM_HERE, session_manager_.release());
     have_shared_secret_ = false;
   }
 
   // Stop XMPP connection synchronously.
   if (signal_strategy_.get()) {
-    signal_strategy_->Close();
+    signal_strategy_->Disconnect();
+    signal_strategy_->RemoveListener(this);
     signal_strategy_.reset();
-
-    for (StatusObserverList::iterator it = status_observers_.begin();
-         it != status_observers_.end(); ++it) {
-      (*it)->OnSignallingDisconnected();
-    }
   }
 
   if (recorder_.get()) {
     StopScreenRecorder();
   } else {
     ShutdownFinish();
   }
 }
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK_EQ(state_, kInitial);
   status_observers_.push_back(observer);
 }
 
 void ChromotingHost::SetSharedSecret(const std::string& shared_secret) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
-  shared_secret_ = shared_secret;
-  have_shared_secret_ = true;
-  if (session_manager_.get()) {
-    session_manager_->set_authenticator_factory(
-        new protocol::V1HostAuthenticatorFactory(
-            key_pair_.GenerateCertificate(), key_pair_.private_key(),
-            shared_secret_));
-  }
+  session_manager_->set_authenticator_factory(
+      new protocol::V1HostAuthenticatorFactory(
+          key_pair_.GenerateCertificate(), key_pair_.private_key(),
+          shared_secret));
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // protocol::ClientSession::EventHandler implementation.
 void ChromotingHost::OnSessionAuthenticated(ClientSession* client) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   // Disconnect all other clients.
   // Iterate over a copy of the list of clients, to avoid mutating the list
   // while iterating over it.
@@ skipping 66 matching lines @@
 
 void ChromotingHost::OnSessionSequenceNumber(ClientSession* session,
                                              int64 sequence_number) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   if (recorder_.get())
     recorder_->UpdateSequenceNumber(sequence_number);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // SignalStrategy::StatusObserver implementations
-void ChromotingHost::OnStateChange(
-    SignalStrategy::StatusObserver::State state) {
+void ChromotingHost::OnSignalStrategyStateChange(
+    SignalStrategy::State state) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
-  if (state == SignalStrategy::StatusObserver::CONNECTED) {
-    LOG(INFO) << "Host connected as " << local_jid_;
-
-    // Create and start session manager.
-    protocol::JingleSessionManager* server =
-        new protocol::JingleSessionManager(context_->network_message_loop());
-
-    server->Init(local_jid_, signal_strategy_.get(),
-                 this, allow_nat_traversal_);
-
-    session_manager_.reset(server);
-    if (have_shared_secret_) {
-      session_manager_->set_authenticator_factory(
-          new protocol::V1HostAuthenticatorFactory(
-              key_pair_.GenerateCertificate(), key_pair_.private_key(),
-              shared_secret_));
-    }
+  if (state == SignalStrategy::CONNECTED) {
+    LOG(INFO) << "Host connected as " << signal_strategy_->GetLocalJid();
 
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
-      (*it)->OnSignallingConnected(signal_strategy_.get(), local_jid_);
+      (*it)->OnSignallingConnected(signal_strategy_.get());
     }
-  } else if (state == SignalStrategy::StatusObserver::CLOSED) {
+  } else if (state == SignalStrategy::CLOSED) {
     LOG(INFO) << "Host disconnected from talk network.";
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnSignallingDisconnected();
     }
   }
 }
 
-void ChromotingHost::OnJidChange(const std::string& full_jid) {
-  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
-  local_jid_ = full_jid;
+bool ChromotingHost::OnSignalStrategyIncomingStanza(
+    const buzz::XmlElement* stanza) {
+  return false;
 }
 
-void ChromotingHost::OnSessionManagerInitialized() {
+void ChromotingHost::OnSessionManagerReady() {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
   // Don't need to do anything here, just wait for incoming
   // connections.
 }
 
 void ChromotingHost::OnIncomingSession(
       protocol::Session* session,
       protocol::SessionManager::IncomingSessionResponse* response) {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
@@ skipping 148 matching lines @@
   }
 
   for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting