Move signaling connection creation out of ChromotingHost.

remoting/host/simple_host_process.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.
 //
 // This is an application of a minimal host process in a Chromoting
 // system. It serves the purpose of gluing different pieces together
 // to make a functional host process for testing.
 //
 // It peforms the following functionality:
 // 1. Connect to the GTalk network and register the machine as a host.
@@ skipping 24 matching lines @@
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_secret.h"
 #include "remoting/host/it2me_host_user_interface.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/register_support_host_request.h"
+#include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/proto/video.pb.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include "ui/gfx/gtk_util.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #elif defined(OS_WIN)
 // TODO(garykac) Make simple host into a proper GUI app on Windows so that we
 // have an hModule for the dialog resource.
 HMODULE g_hModule = NULL;
 #endif
 
 using remoting::ChromotingHost;
 using remoting::DesktopEnvironment;
-using remoting::kChromotingTokenDefaultServiceName;
-using remoting::kXmppAuthServiceConfigPath;
 using remoting::It2MeHostUserInterface;
 using remoting::protocol::CandidateSessionConfig;
 using remoting::protocol::ChannelConfig;
 using std::string;
 using std::wstring;
 
 #if defined(OS_WIN)
 const wchar_t kDefaultConfigPath[] = L".ChromotingConfig.json";
 const wchar_t kHomeDrive[] = L"HOMEDRIVE";
 const wchar_t kHomePath[] = L"HOMEPATH";
@@ skipping 20 matching lines @@
       : fake_(false),
         is_it2me_(false) {
   }
 
   int Run() {
     // |message_loop| is declared early so that any code we call into which
     // requires a current message-loop won't complain.
     // It needs to be a UI message loop to keep runloops spinning on the Mac.
     MessageLoop message_loop(MessageLoop::TYPE_UI);
 
-    remoting::ChromotingHostContext context(
-        base::MessageLoopProxy::current());
-    context.Start();
-
     base::Thread file_io_thread("FileIO");
     file_io_thread.Start();
 
     FilePath config_path = GetConfigPath();
     scoped_refptr<remoting::JsonHostConfig> config =
         new remoting::JsonHostConfig(
             config_path, file_io_thread.message_loop_proxy());
     if (!config->Read()) {
       LOG(ERROR) << "Failed to read configuration file "
                  << config_path.value();
-      context.Stop();
       return 1;
     }
 
-    // For the simple host, we assume we always use the ClientLogin token for
-    // chromiumsync because we do not have an HTTP stack with which we can
-    // easily request an OAuth2 access token even if we had a RefreshToken for
-    // the account.
-    config->SetString(kXmppAuthServiceConfigPath,
-                      kChromotingTokenDefaultServiceName);
+    remoting::ChromotingHostContext context(
+        base::MessageLoopProxy::current());
+    context.Start();
 
-    // Initialize AccessVerifier.
-    // TODO(jamiewalch): For the IT2Me case, the access verifier is passed to
-    // RegisterSupportHostRequest::Init, so transferring ownership of it to the
-    // ChromotingHost could cause a crash condition if SetIT2MeAccessCode is
-    // called after the ChromotingHost is destroyed (for example, at shutdown).
-    // Fix this.
-    scoped_ptr<remoting::RegisterSupportHostRequest> register_request;
-    scoped_ptr<remoting::HeartbeatSender> heartbeat_sender;
-    scoped_ptr<remoting::LogToServer> log_to_server;
-    if (is_it2me_) {
-      register_request.reset(new remoting::RegisterSupportHostRequest());
-      if (!register_request->Init(
-              config, base::Bind(&SimpleHost::SetIT2MeAccessCode,
-                                 base::Unretained(this)))) {
-        return 1;
-      }
+    // Use an XMPP connection to the Talk network for session signalling.
+    std::string xmpp_login;
+    std::string xmpp_auth_token;
+    if (!config->GetString(remoting::kXmppLoginConfigPath, &xmpp_login) ||
+        !config->GetString(remoting::kXmppAuthTokenConfigPath,
+                           &xmpp_auth_token)) {
+      LOG(ERROR) << "XMPP credentials are not defined in the config.";
+      return 1;
     }
-    log_to_server.reset(new remoting::LogToServer(
-        context.network_message_loop()));
+    std::string xmpp_auth_service;
+    if (!config->GetString(remoting::kXmppAuthServiceConfigPath,
+                           &xmpp_auth_service)) {
+      // For the simple host, we assume we always use the ClientLogin token for
+      // chromiumsync because we do not have an HTTP stack with which we can
+      // easily request an OAuth2 access token even if we had a RefreshToken for
+      // the account.
+      xmpp_auth_service = remoting::kChromotingTokenDefaultServiceName;
+    }
+
+    // Create and start XMPP connection.
+    scoped_ptr<remoting::SignalStrategy> signal_strategy(
+        new remoting::XmppSignalStrategy(context.jingle_thread(), xmpp_login,
+                                         xmpp_auth_token, xmpp_auth_service));
+
 
     // Construct a chromoting host.
     scoped_ptr<DesktopEnvironment> desktop_environment;
     if (fake_) {
       remoting::Capturer* capturer =
           new remoting::CapturerFake();
       remoting::EventExecutor* event_executor =
           remoting::EventExecutor::Create(context.desktop_message_loop(),
                                           capturer);
       desktop_environment.reset(
           new DesktopEnvironment(&context, capturer, event_executor));
     } else {
       desktop_environment.reset(DesktopEnvironment::Create(&context));
     }
 
-    host_ = ChromotingHost::Create(
-        &context, config, desktop_environment.get(), false);
+    host_ = new ChromotingHost(&context, config, signal_strategy.get(),
+                               desktop_environment.get(), false);
     host_->set_it2me(is_it2me_);
 
+    scoped_ptr<remoting::LogToServer> log_to_server;
+    log_to_server.reset(new remoting::LogToServer(signal_strategy.get()));
+    host_->AddStatusObserver(log_to_server.get());
+
     scoped_ptr<It2MeHostUserInterface> it2me_host_user_interface;
     if (is_it2me_) {
       it2me_host_user_interface.reset(new It2MeHostUserInterface(host_,
                                                                  &context));
       it2me_host_user_interface->Init();
       host_->AddStatusObserver(it2me_host_user_interface.get());
     }
 
     if (protocol_config_.get()) {
       host_->set_protocol_config(protocol_config_.release());
     }
 
+    scoped_ptr<remoting::RegisterSupportHostRequest> register_request;
+    scoped_ptr<remoting::HeartbeatSender> heartbeat_sender;
     if (is_it2me_) {
-      host_->AddStatusObserver(register_request.get());
+      register_request.reset(new remoting::RegisterSupportHostRequest());
+      if (!register_request->Init(signal_strategy.get(), config,
+                                  base::Bind(&SimpleHost::SetIT2MeAccessCode,
+                                             base::Unretained(this)))) {
+        return 1;
+      }
     } else {
       // Initialize HeartbeatSender.
       heartbeat_sender.reset(
-          new remoting::HeartbeatSender(context.network_message_loop(),
-                                        config));
-      if (!heartbeat_sender->Init())
+          new remoting::HeartbeatSender());
+      if (!heartbeat_sender->Init(signal_strategy.get(), config))
         return 1;
-      host_->AddStatusObserver(heartbeat_sender.get());
     }
-    host_->AddStatusObserver(log_to_server.get());
+
+    // Post a task to start XMPP connection.
+    context.network_message_loop()->PostTask(
+        FROM_HERE, base::Bind(&remoting::SignalStrategy::Connect,
+                              base::Unretained(signal_strategy.get())));
 
     // Let the chromoting host run until the shutdown task is executed.
     host_->Start();
 
     // Set an empty shared-secret for Me2Me.
     // TODO(lambroslambrou): This is a temporary fix, pending a Me2Me-specific
     // AuthenticatorFactory - crbug.com/105214.
     if (!is_it2me_) {
       context.network_message_loop()->PostTask(
           FROM_HERE, base::Bind(&ChromotingHost::SetSharedSecret, host_.get(),
@@ skipping 105 matching lines @@
       LOG(ERROR) << "Unknown video codec: " << video_codec;
       return 1;
     }
     config->mutable_video_configs()->push_back(ChannelConfig(
         transport, remoting::protocol::kDefaultStreamVersion, codec));
     simple_host.set_protocol_config(config.release());
   }
 
   return simple_host.Run();
 }