Chromoting: Move host input and window mgmt into DesktopEnvironment

remoting/host/desktop_environment.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.
 
 #include "remoting/host/desktop_environment.h"
 
 #include "remoting/host/capturer.h"
+#include "remoting/host/chromoting_host.h"
+#include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/continue_window.h"
 #include "remoting/host/curtain.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/local_input_monitor.h"
 
+static const int kContinueWindowTimeoutSecs = 10 * 60;
+
 namespace remoting {
 
-DesktopEnvironment::DesktopEnvironment(Capturer* capturer,
+// static
+DesktopEnvironment* DesktopEnvironment::Create(ChromotingHostContext* context) {
+  Capturer* capturer = Capturer::Create();
+  EventExecutor* event_executor =
+      EventExecutor::Create(context->desktop_message_loop(), capturer);
+  Curtain* curtain = Curtain::Create();
+  DisconnectWindow* disconnect_window = DisconnectWindow::Create();
+  ContinueWindow* continue_window = ContinueWindow::Create();
+  LocalInputMonitor* local_input_monitor = LocalInputMonitor::Create();
+
+  return new DesktopEnvironment(context, capturer, event_executor, curtain,
+                                disconnect_window, continue_window,
+                                local_input_monitor);
+}
+
+DesktopEnvironment::DesktopEnvironment(ChromotingHostContext* context,
+                                       Capturer* capturer,
                                        EventExecutor* event_executor,
                                        Curtain* curtain,
                                        DisconnectWindow* disconnect_window,
                                        ContinueWindow* continue_window,
                                        LocalInputMonitor* local_input_monitor)
-    : capturer_(capturer),
+    : host_(NULL),
+      context_(context),
+      capturer_(capturer),
       event_executor_(event_executor),
       curtain_(curtain),
       disconnect_window_(disconnect_window),
       continue_window_(continue_window),
-      local_input_monitor_(local_input_monitor) {
+      local_input_monitor_(local_input_monitor),
+      is_monitoring_local_inputs_(false) {
 }
 
 DesktopEnvironment::~DesktopEnvironment() {
 }
 
+void DesktopEnvironment::OnConnect(const std::string& username) {
+  MonitorLocalInputs(true);
+  ShowDisconnectWindow(true, username);
+  StartContinueWindowTimer(true);
+}
+
+void DesktopEnvironment::OnLastDisconnect() {
+  MonitorLocalInputs(false);
+  ShowDisconnectWindow(false, std::string());
+  ShowContinueWindow(false);
+  StartContinueWindowTimer(false);
+}
+
+void DesktopEnvironment::OnPause(bool pause) {
+  StartContinueWindowTimer(!pause);
+}
+
+void DesktopEnvironment::MonitorLocalInputs(bool enable) {
+  if (enable == is_monitoring_local_inputs_)
+    return;
+  if (enable) {
+    local_input_monitor_->Start(host_);
+  } else {
+    local_input_monitor_->Stop();
+  }
+  is_monitoring_local_inputs_ = enable;
+}
+
+void DesktopEnvironment::ShowDisconnectWindow(bool show,
+                                              const std::string& username) {
+  if (!context_->IsUIThread()) {

[Sergey Ulanov, 2011/07/08 23:12:24]

I was suggesting that we change ChromotingHost to make sure that it calls this
code only from UI thread. This code would just DCHECK() if it is called from the
wrong thread?

+    context_->PostToUIThread(
+        FROM_HERE,
+        NewRunnableMethod(this, &DesktopEnvironment::ShowDisconnectWindow,
+                          show, username));
+    return;
+  }
+
+  if (show) {
+    disconnect_window_->Show(host_, username);
+  } else {
+    disconnect_window_->Hide();
+  }
+}
+
+void DesktopEnvironment::ShowContinueWindow(bool show) {
+  if (!context_->IsUIThread()) {
+    context_->PostToUIThread(
+        FROM_HERE,
+        NewRunnableMethod(this, &DesktopEnvironment::ShowContinueWindow, show));
+    return;
+  }
+
+  if (show) {
+    continue_window_->Show(host_);
+  } else {
+    continue_window_->Hide();
+  }
+}
+
+void DesktopEnvironment::StartContinueWindowTimer(bool start) {
+  if (context_->main_message_loop() != MessageLoop::current()) {
+    context_->main_message_loop()->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this,
+                          &DesktopEnvironment::StartContinueWindowTimer,
+                          start));
+    return;
+  }
+  if (continue_window_timer_.IsRunning() == start)
+    return;
+  if (start) {
+    continue_window_timer_.Start(
+        base::TimeDelta::FromSeconds(kContinueWindowTimeoutSecs),
+        this, &DesktopEnvironment::ContinueWindowTimerFunc);
+  } else {
+    continue_window_timer_.Stop();
+  }
+}
+
+void DesktopEnvironment::ContinueWindowTimerFunc() {
+  host_->PauseSession(true);
+  ShowContinueWindow(true);
+}
+
+
 }  // namespace remoting