[Chromoting] Moving the daemon IPC channel to ChromotingHostContext.

remoting/host/remoting_me2me_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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #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/files/file_path_watcher.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_native_library.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "crypto/nss_util.h"
+#include "ipc/ipc_channel.h"
+#include "ipc/ipc_channel_proxy.h"
 #include "net/base/network_change_notifier.h"
 #include "net/socket/ssl_server_socket.h"
 #include "remoting/base/breakpad.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/composite_host_config.h"
 #include "remoting/host/constants.h"
 #include "remoting/host/desktop_environment.h"
@@ skipping 29 matching lines @@
 
 #if defined(TOOLKIT_GTK)
 #include "ui/gfx/gtk_util.h"
 #endif  // defined(TOOLKIT_GTK)
 
 namespace {
 
 // This is used for tagging system event logs.
 const char kApplicationName[] = "chromoting";
 
+// The command line switch specifying the name of the Chromoting IPC channel.
+const char kDaemonIpcSwitchName[] = "chromoting-ipc";
+
 // 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 kDefaultHostConfigFile[] =
     FILE_PATH_LITERAL("host.json");
 
 const int kMinPortNumber = 12400;
 const int kMaxPortNumber = 12409;
 
 const char kUnofficialOAuth2ClientId[] =
     "440925447803-2pi3v45bff6tp1rde2f7q6lgbor3o5uj.apps.googleusercontent.com";
 const char kUnofficialOAuth2ClientSecret[] = "W2ieEsG-R1gIA4MMurGrgMc_";
 
 const char kOfficialOAuth2ClientId[] =
     "440925447803-avn2sj1kc099s0r7v62je5s339mu0am1.apps.googleusercontent.com";
 const char kOfficialOAuth2ClientSecret[] = "Bgur6DFiOMM1h8x-AQpuTQlK";
 
 }  // namespace
 
 namespace remoting {
 
 class HostProcess
-    : public HeartbeatSender::Listener {
+    : public HeartbeatSender::Listener,
+      public IPC::Listener {
  public:
   HostProcess()
       : message_loop_(MessageLoop::TYPE_UI),
 #ifdef OFFICIAL_BUILD
         oauth_use_official_client_id_(true),
 #else
         oauth_use_official_client_id_(false),
 #endif
         allow_nat_traversal_(true),
         restarting_(false),
         shutting_down_(false),
         exit_code_(kSuccessExitCode)
 #if defined(OS_MACOSX)
       , curtain_(base::Bind(&HostProcess::OnDisconnectRequested,
                             base::Unretained(this)),
                  base::Bind(&HostProcess::OnDisconnectRequested,
                             base::Unretained(this)))
 #endif
   {
     context_.reset(
         new ChromotingHostContext(message_loop_.message_loop_proxy()));
     context_->Start();
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
     config_updated_timer_.reset(new base::DelayTimer<HostProcess>(
         FROM_HERE, base::TimeDelta::FromSeconds(2), this,
         &HostProcess::ConfigUpdatedDelayed));
   }
 
   bool InitWithCommandLine(const CommandLine* cmd_line) {
+    // Connect to the daemon process.
+    std::string channel_name =
+        cmd_line->GetSwitchValueASCII(kDaemonIpcSwitchName);
+
+#if defined(REMOTING_MULTI_PROCESS)
+    if (channel_name.empty())
+      return false;
+#endif  // defined(REMOTING_MULTI_PROCESS)
+
+    if (!channel_name.empty()) {
+      daemon_channel_.reset(new IPC::ChannelProxy(
+          channel_name, IPC::Channel::MODE_CLIENT, this,
+          context_->network_task_runner()));
+    }
+
     FilePath default_config_dir = remoting::GetConfigDir();
     if (cmd_line->HasSwitch(kAuthConfigSwitchName)) {
       FilePath path = cmd_line->GetSwitchValuePath(kAuthConfigSwitchName);
       config_.AddConfigPath(path);
     }
 
     host_config_path_ = default_config_dir.Append(kDefaultHostConfigFile);
     if (cmd_line->HasSwitch(kHostConfigSwitchName)) {
       host_config_path_ = cmd_line->GetSwitchValuePath(kHostConfigSwitchName);
     }
@@ skipping 70 matching lines @@
 
   void CreateAuthenticatorFactory() {
     DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
     scoped_ptr<protocol::AuthenticatorFactory> factory(
         new protocol::Me2MeHostAuthenticatorFactory(
             key_pair_.GenerateCertificate(),
             *key_pair_.private_key(), host_secret_hash_));
     host_->SetAuthenticatorFactory(factory.Pass());
   }
 
+  // IPC::Listener implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    return false;
+  }
+
   int Run() {
     if (!LoadConfig()) {
       return kInvalidHostConfigurationExitCode;
     }
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset(new HostUserInterface(context_.get()));
 #endif
 
     StartWatchingPolicy();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     context_->file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForConfigChanges,
                    base::Unretained(this)));
 #endif
     message_loop_.Run();
 
 #if defined(OS_MACOSX) || defined(OS_WIN)
     host_user_interface_.reset();
 #endif
 
+    daemon_channel_.reset();
     base::WaitableEvent done_event(true, false);
     policy_watcher_->StopWatching(&done_event);
     done_event.Wait();
     policy_watcher_.reset();
 
     return exit_code_;
   }
 
   // Overridden from HeartbeatSender::Listener
   virtual void OnUnknownHostIdError() OVERRIDE {
@@ skipping 313 matching lines @@
     log_to_server_.reset();
     heartbeat_sender_.reset();
     signaling_connector_.reset();
     signal_strategy_.reset();
 
     message_loop_.PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   MessageLoop message_loop_;
   scoped_ptr<ChromotingHostContext> context_;
+  scoped_ptr<IPC::ChannelProxy> daemon_channel_;
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 
   FilePath host_config_path_;
   CompositeHostConfig config_;
 
   std::string host_id_;
   HostKeyPair key_pair_;
   protocol::SharedSecretHash host_secret_hash_;
   std::string xmpp_login_;
   std::string xmpp_auth_token_;
@@ skipping 117 matching lines @@
             user32.GetFunctionPointer("SetProcessDPIAware"));
     set_process_dpi_aware();
   }
 
   // CommandLine::Init() ignores the passed |argc| and |argv| on Windows getting
   // the command line from GetCommandLineW(), so we can safely pass NULL here.
   return main(0, NULL);
 }
 
 #endif  // defined(OS_WIN)