Move signaling connection creation out of ChromotingHost.

remoting/host/chromoting_host.cc

 // Copyright (c) 2012 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"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/screen_recorder.h"
-#include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/session_config.h"
 #include "remoting/protocol/v1_authenticator.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
 
 namespace remoting {
 
-// static
-ChromotingHost* ChromotingHost::Create(ChromotingHostContext* context,
-                                       MutableHostConfig* config,
-                                       DesktopEnvironment* environment,
-                                       bool allow_nat_traversal) {
-  return new ChromotingHost(context, config, environment, allow_nat_traversal);
-}
-
 ChromotingHost::ChromotingHost(ChromotingHostContext* context,
                                MutableHostConfig* config,
+                               SignalStrategy* signal_strategy,
                                DesktopEnvironment* environment,
                                bool allow_nat_traversal)
     : context_(context),
       desktop_environment_(environment),
       config_(config),
       allow_nat_traversal_(allow_nat_traversal),
       have_shared_secret_(false),
+      signal_strategy_(signal_strategy),
       stopping_recorders_(0),
       state_(kInitial),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
       is_it2me_(false) {
+  DCHECK(context_);
+  DCHECK(signal_strategy);
   DCHECK(desktop_environment_);
   desktop_environment_->set_host(this);
 }
 
 ChromotingHost::~ChromotingHost() {
   DCHECK(clients_.empty());
 }
 
 void ChromotingHost::Start() {
   if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::Start, this));
     return;
   }
 
   LOG(INFO) << "Starting host";
-  DCHECK(!signal_strategy_.get());
 
   // Make sure this object is not started.
   if (state_ != kInitial)
     return;
   state_ = kStarted;
 
   // Assign key and certificate to server.
   if (!key_pair_.Load(config_)) {
     LOG(ERROR) << "Failed to load key pair for the host.";
     return;
   }
 
-  // Use an XMPP connection to the Talk network for session signalling.
-  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_->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_);
+  session_manager_->Init(signal_strategy_, this, allow_nat_traversal_);
 }
 
 // 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 20 matching lines @@
     session_manager_->Close();
     // It may not be safe to delete |session_manager_| here becase
     // 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_->Disconnect();
-    signal_strategy_->RemoveListener(this);
-    signal_strategy_.reset();
-  }
-
   if (recorder_.get()) {
     StopScreenRecorder();
   } else {
     ShutdownFinish();
   }
 }
 
 void ChromotingHost::AddStatusObserver(HostStatusObserver* observer) {
   DCHECK_EQ(state_, kInitial);
   status_observers_.push_back(observer);
@@ skipping 82 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::OnSignalStrategyStateChange(
-    SignalStrategy::State state) {
-  DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
-
-  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());
-    }
-  } else if (state == SignalStrategy::DISCONNECTED) {
-    LOG(INFO) << "Host disconnected from talk network.";
-    for (StatusObserverList::iterator it = status_observers_.begin();
-         it != status_observers_.end(); ++it) {
-      (*it)->OnSignallingDisconnected();
-    }
-  }
-}
-
 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 143 matching lines @@
   }
 
   for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting