[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 <utility>
 
 #include "base/at_exit.h"
+#include "base/atomic_sequence_num.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/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_native_library.h"
 #include "base/string_util.h"
@@ skipping 12 matching lines @@
 #include "remoting/base/auto_thread_task_runner.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/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/daemon_sender.h"
 #include "remoting/host/desktop_environment_factory.h"
 #include "remoting/host/desktop_resizer.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_desktop_environment_factory.h"
 #include "remoting/host/json_host_config.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"
 #include "remoting/jingle_glue/xmpp_signal_strategy.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,
+#if defined(REMOTING_MULTI_PROCESS)
+      public DaemonSender,
+#endif  // defined(REMOTING_MULTI_PROCESS)
+      public HeartbeatSender::Listener,
+      public IPC::Listener {
  public:
   explicit HostProcess(scoped_ptr<ChromotingHostContext> context)
       : context_(context.Pass()),
         config_(FilePath()),
         allow_nat_traversal_(true),
         restarting_(false),
         shutting_down_(false),
-#if defined(OS_WIN)
+#if defined(OS_WIN) && defined(REMOTING_MULTI_PROCESS)
+        desktop_environment_factory_(new IpcDesktopEnvironmentFactory(
+            context_->input_task_runner(),
+            context_->ui_task_runner(),
+            ALLOW_THIS_IN_INITIALIZER_LIST(this))),
+#elif defined(OS_WIN) && !defined(REMOTING_MULTI_PROCESS)
         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()),
         exit_code_(kSuccessExitCode) {
     network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
     curtain_ = CurtainMode::Create(
@@ skipping 138 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_HANDLER(ChromotingDaemonNetworkMsg_TerminalClosed,
+                            OnTerminalClosed)
         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;
     }
 
     context_->network_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&HostProcess::ListenForShutdownSignal,
                    base::Unretained(this)));
 
     StartWatchingConfigChanges();
   }
 
   int get_exit_code() const { return exit_code_; }
 
+#if defined(REMOTING_MULTI_PROCESS)
+  // DaemonSender implementation
+  virtual void CloseTerminal(DesktopEnvironment* desktop_environment) OVERRIDE;
+  virtual void OpenTerminal(DesktopEnvironment* desktop_environment) OVERRIDE;
+
+  // Maps |termonal_id| to the correspondinf desktop environment instance and

[Wez, 2012/10/13 00:47:15]

typo: |terminal_id|

[Wez, 2012/10/13 00:47:15]

typo: corresponding

[Wez, 2012/10/13 00:47:15]

nit: desktop environment -> DesktopEnvironment

[Wez, 2012/10/13 00:47:15]

nit: Reword "Closes any client connection that is using the specified
|terminal_id|".

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

+  // closes the corresponding connection if needed.
+  void OnTerminalClosed(int terminal_id);
+#endif  // defined(REMOTING_MULTI_PROCESS)
+
  private:
   void ShutdownHostProcess() {
     DCHECK(context_->ui_task_runner()->BelongsToCurrentThread());
 
     // Tear down resources that use ChromotingHostContext threads.
     config_watcher_.reset();
     daemon_channel_.reset();
     desktop_environment_factory_.reset();
     host_user_interface_.reset();
 
@@ skipping 365 matching lines @@
   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_;
 
   int exit_code_;
+
+#if defined(REMOTING_MULTI_PROCESS)
+  // A list of desktop environment instances known to the daemon process.
+  std::map<int, DesktopEnvironment*> registered_terminals_;

[Wez, 2012/10/13 00:47:15]

nit: registered -> active

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

+
+  // This gives us more than 67 years of unique IDs assuming a new ID is
+  // allocated every second.
+  static base::StaticAtomicSequenceNumber terminal_id_;

[Wez, 2012/10/13 00:47:15]

Do we need StatucAtomicSequenceNumber; we're not running OpenTerminal() on
multiple threads...

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

+#endif  // defined(REMOTING_MULTI_PROCESS)
+
 };
 
+#if defined(REMOTING_MULTI_PROCESS)

[Wez, 2012/10/13 00:47:15]

I really think we need to move the multi-process stuff out of here.

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

+
+base::StaticAtomicSequenceNumber HostProcess::terminal_id_;
+
+void HostProcess::CloseTerminal(DesktopEnvironment* desktop_environment) {
+  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+
+  std::map<int, DesktopEnvironment*>::iterator i;
+  for (i = registered_terminals_.begin(); i != registered_terminals_.end();
+       ++i) {
+    if (i->second == desktop_environment)
+      break;
+  }
+
+  if (i != registered_terminals_.end()) {
+    int terminal_id = i->first;
+    registered_terminals_.erase(i);
+
+    VLOG(1) << "Network: unregistered desktop environment " << terminal_id;
+    daemon_channel_->Send(
+        new ChromotingNetworkHostMsg_CloseTerminal(terminal_id));
+  }
+}
+
+void HostProcess::OpenTerminal(DesktopEnvironment* desktop_environment) {

[Wez, 2012/10/13 00:47:15]

OpenTerminal -> CreateTerminal / AttachTerminal

[alexeypa (please no reviews), 2012/10/16 19:32:25]

Done.

+  DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
+
+  int terminal_id = terminal_id_.GetNext();
+  bool inserted = registered_terminals_.insert(
+      std::make_pair(terminal_id, desktop_environment)).second;
+  CHECK(inserted);
+
+  VLOG(1) << "Network: registered desktop environment " << terminal_id;
+  daemon_channel_->Send(new ChromotingNetworkHostMsg_OpenTerminal(terminal_id));
+}
+
+void HostProcess::OnTerminalClosed(int terminal_id) {
+  if (!context_->network_task_runner()->BelongsToCurrentThread()) {
+    context_->network_task_runner()->PostTask(FROM_HERE, base::Bind(
+        &HostProcess::OnTerminalClosed, base::Unretained(this), terminal_id));
+    return;
+  }
+
+  std::map<int, DesktopEnvironment*>::iterator i =
+      registered_terminals_.find(terminal_id);
+  if (i != registered_terminals_.end()) {
+    DesktopEnvironment* desktop_environment = i->second;
+    registered_terminals_.erase(i);

[Wez, 2012/10/13 00:47:15]

Why not let the client disconnection trigger CloseTerminal() is it would if the
client disconnected normally, so that the daemon code will always get a close
IPC for every terminal?

[alexeypa (please no reviews), 2012/10/16 19:32:25]

This gives one less message sent over IPC and makes it easier to reason about
the race between CloseTerminal and TerminalClosed.

+
+    // Disconnect the client for given desktop environment.
+    host_->DisconnectClient(desktop_environment);
+  }
+}
+
+#endif  // defined(REMOTING_MULTI_PROCESS)
+
 }  // 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
 
   CommandLine::Init(argc, argv);
 
@@ skipping 92 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)