Move signaling connection creation out of ChromotingHost.

remoting/host/remoting_me2me_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.
 //
 // This file implements a standalone host process for Me2Me, which is currently
 // used for the Linux-only Virtual Me2Me build.
 
 #include <stdlib.h>
 
 #include <string>
@@ skipping 11 matching lines @@
 #include "crypto/nss_util.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/capturer.h"
 #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_config.h"
 #include "remoting/host/json_host_config.h"
+#include "remoting/jingle_glue/xmpp_signal_strategy.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif
 
 namespace {
 // These are used for parsing the config-file locations from the command line,
 // and for defining the default locations if the switches are not present.
 const char kAuthConfigSwitchName[] = "auth-config";
 const char kHostConfigSwitchName[] = "host-config";
@@ skipping 42 matching lines @@
     context.Start();
 
     base::Thread file_io_thread("FileIO");
     file_io_thread.Start();
 
     if (!LoadConfig(file_io_thread.message_loop_proxy())) {
       context.Stop();
       return 1;
     }
 
+    // Use an XMPP connection to the Talk network for session signalling.
+    std::string xmpp_login;
+    std::string xmpp_auth_token;
+    if (!auth_config_->GetString(kXmppLoginConfigPath, &xmpp_login) ||
+        !auth_config_->GetString(kXmppAuthTokenConfigPath, &xmpp_auth_token)) {
+      LOG(ERROR) << "XMPP credentials are not defined in the config.";
+      return 1;
+    }
+
+    std::string xmpp_auth_service;
+    if (!auth_config_->GetString(remoting::kXmppAuthServiceConfigPath,
+                                 &xmpp_auth_service)) {
+      // For the me2me host, we assume we 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<SignalStrategy> signal_strategy(
+        new XmppSignalStrategy(context.jingle_thread(), xmpp_login,
+                               xmpp_auth_token, xmpp_auth_service));
+
     // Create the DesktopEnvironment and ChromotingHost.
     scoped_ptr<DesktopEnvironment> desktop_environment(
         DesktopEnvironment::Create(&context));
 
-    host_ = ChromotingHost::Create(
-        &context, host_config_, desktop_environment.get(), false);
+    host_ = new ChromotingHost(
+        &context, host_config_, signal_strategy.get(),
+        desktop_environment.get(), false);
 
     // Initialize HeartbeatSender.
     scoped_ptr<remoting::HeartbeatSender> heartbeat_sender(
-        new remoting::HeartbeatSender(context.network_message_loop(),
-                                      host_config_));
-    if (!heartbeat_sender->Init()) {
+        new remoting::HeartbeatSender());
+    if (!heartbeat_sender->Init(signal_strategy.get(), host_config_)) {
       context.Stop();
       return 1;
     }
-    host_->AddStatusObserver(heartbeat_sender.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())));
 
     // Run the ChromotingHost 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.
     context.network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::SetSharedSecret, host_.get(),
                               ""));
 
     message_loop.MessageLoop::Run();
 
     // And then stop the chromoting context.
     context.Stop();
     file_io_thread.Stop();
 
     host_ = NULL;
 
     return 0;
   }
 
  private:
   // Read Host config from disk, returning true if successful.
   bool LoadConfig(base::MessageLoopProxy* message_loop_proxy) {
     host_config_ =
         new remoting::JsonHostConfig(host_config_path_, message_loop_proxy);
-    scoped_refptr<remoting::JsonHostConfig> auth_config =
+    auth_config_ =
         new remoting::JsonHostConfig(auth_config_path_, message_loop_proxy);
 
     std::string failed_path;
     if (!host_config_->Read()) {
       failed_path = host_config_path_.value();
-    } else if (!auth_config->Read()) {
+    } else if (!auth_config_->Read()) {
       failed_path = auth_config_path_.value();
     }
     if (!failed_path.empty()) {
       LOG(ERROR) << "Failed to read configuration file " << failed_path;
       return false;
     }
 
-    // Copy the needed keys from |auth_config| into |host_config|.
-    std::string value;
-    auth_config->GetString(kXmppAuthTokenConfigPath, &value);
-    host_config_->SetString(kXmppAuthTokenConfigPath, value);
-    auth_config->GetString(kXmppLoginConfigPath, &value);
-    host_config_->SetString(kXmppLoginConfigPath, value);
-
-    // For the Me2Me 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.
-    host_config_->SetString(kXmppAuthServiceConfigPath,
-                           kChromotingTokenDefaultServiceName);
     return true;
   }
 
   FilePath auth_config_path_;
   FilePath host_config_path_;
 
+  scoped_refptr<remoting::JsonHostConfig> auth_config_;
   scoped_refptr<remoting::JsonHostConfig> host_config_;
 
   scoped_refptr<ChromotingHost> host_;
 };
 
 }  // namespace remoting
 
 int main(int argc, char** argv) {
   CommandLine::Init(argc, argv);
 
   // This object instance is required by Chrome code (for example,
   // LazyInstance, MessageLoop).
   base::AtExitManager exit_manager;
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
 #if defined(TOOLKIT_USES_GTK)
   // Required for any calls into GTK functions, such as the Disconnect and
   // Continue windows, though these should not be used for the Me2Me case
   // (crbug.com/104377).
   gfx::GtkInitFromCommandLine(*cmd_line);
 #endif  // TOOLKIT_USES_GTK
 
   remoting::HostProcess me2me_host;
   me2me_host.InitWithCommandLine(cmd_line);
 
   return me2me_host.Run();
 }