Tiny little refactoring of DesktopEnvironment.

remoting/host/ipc_desktop_environment.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.
 
 #include "remoting/host/ipc_desktop_environment.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/platform_file.h"
 #include "base/single_thread_task_runner.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/capturer/capture_data.h"
 #include "remoting/capturer/video_frame_capturer.h"
+#include "remoting/codec/audio_encoder.h"
+#include "remoting/codec/video_encoder.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/desktop_session_connector.h"
 #include "remoting/host/desktop_session_proxy.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/ipc_audio_capturer.h"
-#include "remoting/host/ipc_event_executor.h"
 #include "remoting/host/ipc_video_frame_capturer.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif  // defined(OS_WIN)
 
 namespace remoting {
 
 IpcDesktopEnvironment::IpcDesktopEnvironment(
-    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
-    DesktopSessionConnector* desktop_session_connector,
-    scoped_refptr<DesktopSessionProxy> desktop_session_proxy)
-    : DesktopEnvironment(
-          scoped_ptr<AudioCapturer>(
-              new IpcAudioCapturer(desktop_session_proxy)),
-          scoped_ptr<EventExecutor>(
-              new IpcEventExecutor(desktop_session_proxy)),
-          scoped_ptr<VideoFrameCapturer>(
-              new IpcVideoFrameCapturer(desktop_session_proxy))),
-      network_task_runner_(network_task_runner),
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    const std::string& client_jid,
+    const base::Closure& disconnect_callback,
+    base::WeakPtr<DesktopSessionConnector> desktop_session_connector)
+    : caller_task_runner_(caller_task_runner),
+      connected_(false),
       desktop_session_connector_(desktop_session_connector),
-      desktop_session_proxy_(desktop_session_proxy),
-      connected_(false) {
+      desktop_session_proxy_(new DesktopSessionProxy(caller_task_runner,
+                                                     client_jid,
+                                                     disconnect_callback)) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 IpcDesktopEnvironment::~IpcDesktopEnvironment() {
-  if (connected_) {
-    connected_ = false;
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  if (connected_ && desktop_session_connector_)
     desktop_session_connector_->DisconnectTerminal(desktop_session_proxy_);
+
+  connected_ = false;
+  desktop_session_proxy_->Stop();
+}
+
+void IpcDesktopEnvironment::InjectClipboardEvent(
+    const protocol::ClipboardEvent& event) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  desktop_session_proxy_->InjectClipboardEvent(event);
+}
+
+void IpcDesktopEnvironment::InjectKeyEvent(const protocol::KeyEvent& event) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  desktop_session_proxy_->InjectKeyEvent(event);
+}
+
+void IpcDesktopEnvironment::InjectMouseEvent(
+    const protocol::MouseEvent& event) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  desktop_session_proxy_->InjectMouseEvent(event);
+}
+
+void IpcDesktopEnvironment::StartAudio(
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+    scoped_ptr<AudioEncoder> audio_encoder,
+    protocol::AudioStub* audio_stub) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  RegisterDesktopSessionProxy();
+  desktop_session_proxy_->StartAudio(audio_task_runner, audio_encoder.Pass(),
+                                     audio_stub);
+}
+
+void IpcDesktopEnvironment::PauseAudio(bool pause) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  desktop_session_proxy_->PauseAudio(pause);
+}
+
+void IpcDesktopEnvironment::StartInput(
+    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    protocol::ClipboardStub* clipboard_stub) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  RegisterDesktopSessionProxy();
+  desktop_session_proxy_->StartInput(input_task_runner, ui_task_runner,
+                                     clipboard_stub);
+}
+
+void IpcDesktopEnvironment::StartVideo(
+    scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
+    scoped_ptr<VideoEncoder> video_encoder,
+    protocol::CursorShapeStub* cursor_shape_stub,
+    protocol::VideoStub* video_stub) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  RegisterDesktopSessionProxy();
+  desktop_session_proxy_->StartVideo(capture_task_runner,
+                                     encode_task_runner,
+                                     video_encoder.Pass(),
+                                     cursor_shape_stub,
+                                     video_stub);
+}
+
+SkISize IpcDesktopEnvironment::GetScreenSize() const {
+  return desktop_session_proxy_->GetScreenSize();
+}
+
+void IpcDesktopEnvironment::PauseVideo(bool pause) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  desktop_session_proxy_->PauseVideo(pause);
+}
+
+void IpcDesktopEnvironment::UpdateSequenceNumber(int64 sequence_number) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  desktop_session_proxy_->UpdateSequenceNumber(sequence_number);
+}
+
+void IpcDesktopEnvironment::RegisterDesktopSessionProxy() {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  if (!connected_) {
+    connected_ = true;
+    desktop_session_connector_->ConnectTerminal(desktop_session_proxy_);
   }
 }
 
-void IpcDesktopEnvironment::Start(
-    scoped_ptr<protocol::ClipboardStub> client_clipboard,
-    const std::string& client_jid,
-    const base::Closure& disconnect_callback) {
-  DCHECK(network_task_runner_->BelongsToCurrentThread());
-  DCHECK(!connected_);
-
-  desktop_session_proxy_->Initialize(client_jid, disconnect_callback);
-
-  // Register the proxy to receive AttachToDesktop() and DetachFromDesktop()
-  // notifications.
-  connected_ = true;
-  desktop_session_connector_->ConnectTerminal(desktop_session_proxy_);
-
-  DesktopEnvironment::Start(client_clipboard.Pass(), client_jid,
-                            disconnect_callback);
-}
-
 }  // namespace remoting