[Chromoting] Request the daemon to open a terminal once a connection has been accepted.

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"
@@ skipping 23 matching lines @@
 #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/chromoting_messages.h"
 #include "remoting/host/config_file_watcher.h"
 #include "remoting/host/curtain_mode.h"
 #include "remoting/host/curtaining_host_observer.h"
 #include "remoting/host/desktop_environment_factory.h"
 #include "remoting/host/desktop_resizer.h"
+#include "remoting/host/desktop_session_connector.h"
 #include "remoting/host/dns_blackhole_checker.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_event_logger.h"
 #include "remoting/host/host_exit_codes.h"
 #include "remoting/host/host_user_interface.h"
 #include "remoting/host/ipc_consts.h"
+#include "remoting/host/ipc_desktop_environment_factory.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/logging.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/network_settings.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "remoting/host/resizing_host_observer.h"
 #include "remoting/host/session_manager_factory.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/video_frame_capturer.h"
@@ skipping 44 matching lines @@
 
 void QuitMessageLoop(MessageLoop* message_loop) {
   message_loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 }  // namespace
 
 namespace remoting {
 
 class HostProcess
-    : public HeartbeatSender::Listener,
-      public IPC::Listener,
-      public ConfigFileWatcher::Delegate {
+    : public ConfigFileWatcher::Delegate,
+      public HeartbeatSender::Listener,
+      public IPC::Listener {
  public:
   explicit HostProcess(scoped_ptr<ChromotingHostContext> context)
       : context_(context.Pass()),
         allow_nat_traversal_(true),
         restarting_(false),
         shutting_down_(false),
-#if defined(OS_WIN)
-        desktop_environment_factory_(new SessionDesktopEnvironmentFactory(
-            context_->input_task_runner(), context_->ui_task_runner())),
-#else  // !defined(OS_WIN)
-        desktop_environment_factory_(new DesktopEnvironmentFactory(
-            context_->input_task_runner(), context_->ui_task_runner())),
-#endif  // !defined(OS_WIN)
         desktop_resizer_(DesktopResizer::Create()),
+#if defined(REMOTING_MULTI_PROCESS)
+        desktop_session_connector_(NULL),
+#endif  // defined(REMOTING_MULTI_PROCESS)
         exit_code_(kSuccessExitCode) {
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
     curtain_ = CurtainMode::Create(
         base::Bind(&HostProcess::OnDisconnectRequested,
                    base::Unretained(this)),
         base::Bind(&HostProcess::RejectAuthenticatingClient,
                    base::Unretained(this)));
 }
 
 #if defined(REMOTING_MULTI_PROCESS)
@@ skipping 150 matching lines @@
 
   // IPC::Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
 #if defined(REMOTING_MULTI_PROCESS)
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(HostProcess, message)
       IPC_MESSAGE_HANDLER(ChromotingDaemonNetworkMsg_Configuration,
                           OnConfigUpdated)
+      IPC_MESSAGE_FORWARD(ChromotingDaemonNetworkMsg_TerminalDisconnected,
+                          desktop_session_connector_,
+                          DesktopSessionConnector::OnTerminalDisconnected)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
 #else  // !defined(REMOTING_MULTI_PROCESS)
     return false;
 #endif  // !defined(REMOTING_MULTI_PROCESS)
   }
 
   void StartHostProcess() {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     if (!InitWithCommandLine(CommandLine::ForCurrentProcess())) {
       OnConfigWatcherError();
       return;
     }
 
+    // Create a desktop environment factory appropriate to the build type &
+    // platform.
+#if defined(OS_WIN)
+
+#if defined(REMOTING_MULTI_PROCESS)
+    IpcDesktopEnvironmentFactory* desktop_environment_factory =
+        new IpcDesktopEnvironmentFactory(
+            daemon_channel_.get(),
+            context_->input_task_runner(),
+            context_->network_task_runner(),
+            context_->ui_task_runner());
+    desktop_session_connector_ = desktop_environment_factory;
+#else // !defined(REMOTING_MULTI_PROCESS)
+    DesktopEnvironmentFactory* desktop_environment_factory =
+        new SessionDesktopEnvironmentFactory(
+            context_->input_task_runner(), context_->ui_task_runner());
+#endif  // !defined(REMOTING_MULTI_PROCESS)
+
+#else  // !defined(OS_WIN)
+    DesktopEnvironmentFactory* desktop_environment_factory =
+        new DesktopEnvironmentFactory(
+            context_->input_task_runner(), context_->ui_task_runner());
+#endif  // !defined(OS_WIN)
+
+    desktop_environment_factory_.reset(desktop_environment_factory);
+
     context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForShutdownSignal,
                    base::Unretained(this)));
 
     // The host UI should be created on the UI thread.
     bool want_user_interface = true;
 #if defined(OS_LINUX)
     want_user_interface = false;
 #elif defined(OS_MACOSX)
@@ skipping 394 matching lines @@
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
 
   scoped_ptr<HostUserInterface> host_user_interface_;
 
   scoped_refptr<ChromotingHost> host_;
 
+#if defined(REMOTING_MULTI_PROCESS)
+  DesktopSessionConnector* desktop_session_connector_;
+#endif  // defined(REMOTING_MULTI_PROCESS)
+
   int exit_code_;
 };
 
 }  // namespace remoting
 
 int main(int argc, char** argv) {
 #if defined(OS_MACOSX)
   // Needed so we don't leak objects when threads are created.
   base::mac::ScopedNSAutoreleasePool pool;
 #endif
@@ skipping 83 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)