Chromoting: Move host input and window mgmt into DesktopEnvironment

remoting/host/chromoting_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.
 
 #include "remoting/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
-#include "remoting/host/capturer.h"
 #include "remoting/host/chromoting_host_context.h"
-#include "remoting/host/continue_window.h"
 #include "remoting/host/curtain.h"
 #include "remoting/host/desktop_environment.h"
-#include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
-#include "remoting/host/local_input_monitor.h"
 #include "remoting/host/screen_recorder.h"
 #include "remoting/host/user_authenticator.h"
 #include "remoting/jingle_glue/xmpp_signal_strategy.h"
 #include "remoting/proto/auth.pb.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/session_config.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
 
-static const int kContinueWindowTimeoutSecs = 10 * 60;
-
 namespace remoting {
 
 // static
 ChromotingHost* ChromotingHost::Create(ChromotingHostContext* context,
                                        MutableHostConfig* config,
                                        AccessVerifier* access_verifier) {
-  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 Create(context, config,
-                new DesktopEnvironment(capturer, event_executor, curtain,
-                                       disconnect_window, continue_window,
-                                       local_input_monitor),
-                access_verifier);
+  DesktopEnvironment* desktop_env = DesktopEnvironment::Create(context);
+  return Create(context, config, desktop_env, access_verifier);
 }
 
 // static
 ChromotingHost* ChromotingHost::Create(ChromotingHostContext* context,
                                        MutableHostConfig* config,
                                        DesktopEnvironment* environment,
                                        AccessVerifier* access_verifier) {
   return new ChromotingHost(context, config, environment, access_verifier);
 }
 
 ChromotingHost::ChromotingHost(ChromotingHostContext* context,
                                MutableHostConfig* config,
                                DesktopEnvironment* environment,
                                AccessVerifier* access_verifier)
     : context_(context),
       config_(config),
       desktop_environment_(environment),
       access_verifier_(access_verifier),
       state_(kInitial),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
       is_curtained_(false),
-      is_monitoring_local_inputs_(false),
       is_it2me_(false) {
   DCHECK(desktop_environment_.get());
+  desktop_environment_->set_host(this);
 }
 
 ChromotingHost::~ChromotingHost() {
 }
 
 void ChromotingHost::Start() {
   if (MessageLoop::current() != context_->network_message_loop()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::Start, this));
     return;
@@ skipping 51 matching lines @@
     if (state_ == kStopping)
       return;
     state_ = kStopping;
   }
 
   // Make sure ScreenRecorder doesn't write to the connection.
   if (recorder_.get()) {
     recorder_->RemoveAllConnections();
   }
 
-  // Stop local inputs monitor.
-  MonitorLocalInputs(false);
+  // Stop all desktop interaction.
+  desktop_environment_->OnLastDisconnect();
 
   // Disconnect the clients.
   for (size_t i = 0; i < clients_.size(); i++) {
     clients_[i]->Disconnect();
   }
   clients_.clear();
 
   // Stop chromotocol session manager.
   if (session_manager_.get()) {
     session_manager_->Close();
@@ skipping 207 matching lines @@
         FROM_HERE,
         NewRunnableMethod(this,
                           &ChromotingHost::PauseSession,
                           pause));
     return;
   }
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     client->get()->set_awaiting_continue_approval(pause);
   }
-  StartContinueWindowTimer(!pause);
+  desktop_environment_->OnPause(!pause);
 }
 
 void ChromotingHost::OnClientDisconnected(ConnectionToClient* connection) {
   DCHECK_EQ(context_->main_message_loop(), MessageLoop::current());
 
   // Find the client session corresponding to the given connection.
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     if (client->get()->connection() == connection)
       break;
@@ skipping 26 matching lines @@
     for (StatusObserverList::iterator it = status_observers_.begin();
          it != status_observers_.end(); ++it) {
       (*it)->OnAuthenticatedClientsChanged(authenticated_clients);
     }
   }
 
   // Disable the "curtain" if there are no more active clients.
   if (AuthenticatedClientsCount() == 0) {
     EnableCurtainMode(false);
     if (is_it2me_) {
-      MonitorLocalInputs(false);
-      ShowDisconnectWindow(false, std::string());
-      ShowContinueWindow(false);
-      StartContinueWindowTimer(false);
+      desktop_environment_->OnLastDisconnect();
     }
   }
 }
 
 // TODO(sergeyu): Move this to SessionManager?
 Encoder* ChromotingHost::CreateEncoder(const protocol::SessionConfig* config) {
   const protocol::ChannelConfig& video_config = config->video_config();
 
   if (video_config.codec == protocol::ChannelConfig::CODEC_VERBATIM) {
     return EncoderRowBased::CreateVerbatimEncoder();
@@ skipping 29 matching lines @@
 void ChromotingHost::EnableCurtainMode(bool enable) {
   // TODO(jamiewalch): This will need to be more sophisticated when we think
   // about proper crash recovery and daemon mode.
   // TODO(wez): CurtainMode shouldn't be driven directly by ChromotingHost.
   if (is_it2me_ || enable == is_curtained_)
     return;
   desktop_environment_->curtain()->EnableCurtainMode(enable);
   is_curtained_ = enable;
 }
 
-void ChromotingHost::MonitorLocalInputs(bool enable) {
-  if (enable == is_monitoring_local_inputs_)
-    return;
-  if (enable) {
-    desktop_environment_->local_input_monitor()->Start(this);
-  } else {
-    desktop_environment_->local_input_monitor()->Stop();
-  }
-  is_monitoring_local_inputs_ = enable;
-}
-
 void ChromotingHost::LocalLoginSucceeded(
     scoped_refptr<ConnectionToClient> connection) {
   if (MessageLoop::current() != context_->main_message_loop()) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::LocalLoginSucceeded, this,
                               connection));
     return;
   }
 
   protocol::LocalLoginStatus* status = new protocol::LocalLoginStatus();
@@ skipping 28 matching lines @@
                                    encoder);
   }
 
   // Immediately add the connection and start the session.
   recorder_->AddConnection(connection);
   recorder_->Start();
   // TODO(jamiewalch): Tidy up actions to be taken on connect/disconnect,
   // including closing the connection on failure of a critical operation.
   EnableCurtainMode(true);
   if (is_it2me_) {
-    MonitorLocalInputs(true);
     std::string username = connection->session()->jid();
     size_t pos = username.find('/');
     if (pos != std::string::npos)
       username.replace(pos, std::string::npos, "");
-    ShowDisconnectWindow(true, username);
-    StartContinueWindowTimer(true);
+    desktop_environment_->OnConnect(username);
   }
 
   // Notify observers that there is at least one authenticated client.
   for (StatusObserverList::iterator it = status_observers_.begin();
        it != status_observers_.end(); ++it) {
     (*it)->OnAuthenticatedClientsChanged(AuthenticatedClientsCount());
   }
 }
 
 void ChromotingHost::LocalLoginFailed(
@@ skipping 17 matching lines @@
   // Find the client session corresponding to the given connection.
   ClientList::iterator client;
   for (client = clients_.begin(); client != clients_.end(); ++client) {
     if (client->get()->connection() == connection)
       break;
   }
   CHECK(client != clients_.end());
   client->get()->OnAuthorizationComplete(true);
 }
 
-void ChromotingHost::ShowDisconnectWindow(bool show,
-                                          const std::string& username) {
-  if (!context_->IsUIThread()) {
-    context_->PostToUIThread(
-        FROM_HERE,
-        NewRunnableMethod(this, &ChromotingHost::ShowDisconnectWindow,
-                          show, username));
-    return;
-  }
-
-  if (show) {
-    desktop_environment_->disconnect_window()->Show(this, username);
-  } else {
-    desktop_environment_->disconnect_window()->Hide();
-  }
-}
-
-void ChromotingHost::ShowContinueWindow(bool show) {
-  if (!context_->IsUIThread()) {
-    context_->PostToUIThread(
-        FROM_HERE,
-        NewRunnableMethod(this, &ChromotingHost::ShowContinueWindow, show));
-    return;
-  }
-
-  if (show) {
-    desktop_environment_->continue_window()->Show(this);
-  } else {
-    desktop_environment_->continue_window()->Hide();
-  }
-}
-
-void ChromotingHost::StartContinueWindowTimer(bool start) {
-  if (context_->main_message_loop() != MessageLoop::current()) {
-    context_->main_message_loop()->PostTask(
-        FROM_HERE,
-        NewRunnableMethod(this,
-                          &ChromotingHost::StartContinueWindowTimer,
-                          start));
-    return;
-  }
-  if (continue_window_timer_.IsRunning() == start)
-    return;
-  if (start) {
-    continue_window_timer_.Start(
-        base::TimeDelta::FromSeconds(kContinueWindowTimeoutSecs),
-        this, &ChromotingHost::ContinueWindowTimerFunc);
-  } else {
-    continue_window_timer_.Stop();
-  }
-}
-
-void ChromotingHost::ContinueWindowTimerFunc() {
-  PauseSession(true);
-  ShowContinueWindow(true);
-}
-
 void ChromotingHost::ShutdownRecorder() {
   if (MessageLoop::current() != context_->main_message_loop()) {
     context_->main_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::ShutdownRecorder, this));
     return;
   }
 
   if (recorder_.get()) {
     recorder_->Stop(NewRunnableMethod(this, &ChromotingHost::ShutdownFinish));
   } else {
@@ skipping 21 matching lines @@
 
   for (std::vector<Task*>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     (*it)->Run();
     delete *it;
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting