Initial check-in of Linux virtual Me2Me.

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>
+
+#include "base/at_exit.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/command_line.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/threading/thread.h"
+#include "build/build_config.h"
+#include "crypto/nss_util.h"
+#include "remoting/base/constants.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/host/self_access_verifier.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";
+const FilePath::CharType kDefaultConfigDir[] =
+    FILE_PATH_LITERAL(".config/chrome-remote-desktop");
+const FilePath::CharType kDefaultAuthConfigFile[] =
+    FILE_PATH_LITERAL("auth.json");
+const FilePath::CharType kDefaultHostConfigFile[] =
+    FILE_PATH_LITERAL("host.json");
+}
+
+namespace remoting {
+
+class HostProcess {
+ public:
+  HostProcess() {}
+
+  void InitWithCommandLine(const CommandLine* cmd_line) {
+    FilePath default_config_dir =
+        file_util::GetHomeDir().Append(kDefaultConfigDir);
+
+    if (cmd_line->HasSwitch(kAuthConfigSwitchName)) {
+      auth_config_path_ = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
+    } else {
+      auth_config_path_ = default_config_dir.Append(kDefaultAuthConfigFile);
+    }
+
+    if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
+      host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
+    } else {
+      host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
+    }
+  }
+
+  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();
+
+    if (!LoadConfig(file_io_thread.message_loop_proxy())) {
+      context.Stop();
+      return 1;
+    }
+
+    // Initialize AccessVerifier.
+    scoped_ptr<remoting::SelfAccessVerifier> self_access_verifier(
+        new remoting::SelfAccessVerifier());
+    if (!self_access_verifier->Init(host_config_)) {
+      context.Stop();
+      return 1;
+    }
+
+    // Create the DesktopEnvironment and ChromotingHost.
+    scoped_ptr<DesktopEnvironment> desktop_environment(
+        DesktopEnvironment::Create(&context));
+
+    host_ = ChromotingHost::Create(&context, host_config_,
+                                   desktop_environment.get(),
+                                   self_access_verifier.release(), false);
+
+    // Initialize HeartbeatSender.
+    scoped_ptr<remoting::HeartbeatSender> heartbeat_sender(
+        new remoting::HeartbeatSender(context.network_message_loop(),
+                                      host_config_));
+    if (!heartbeat_sender->Init()) {
+      context.Stop();
+      return 1;
+    }
+    host_->AddStatusObserver(heartbeat_sender.get());
+
+    // Run the ChromotingHost until the shutdown task is executed.
+    host_->Start();
+    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 =
+        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()) {
+      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> 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();
+}