Making DesktopEnvironment a factory class used by ClientSession to create audio/video capturers and…

remoting/host/desktop_session_proxy.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/desktop_session_proxy.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/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/ipc_audio_capturer.h"
+#include "remoting/host/ipc_event_executor.h"
 #include "remoting/host/ipc_video_frame_capturer.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif  // defined(OS_WIN)
 
 namespace remoting {
 
 DesktopSessionProxy::DesktopSessionProxy(
-    scoped_refptr<base::SingleThreadTaskRunner> audio_capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> video_capture_task_runner)
-    : audio_capture_task_runner_(audio_capture_task_runner),
-      caller_task_runner_(caller_task_runner),
-      video_capture_task_runner_(video_capture_task_runner),
+    const std::string& client_jid,
+    const base::Closure& disconnect_callback)
+    : caller_task_runner_(caller_task_runner),
+      client_jid_(client_jid),
+      disconnect_callback_(disconnect_callback),
       audio_capturer_(NULL),
       pending_capture_frame_requests_(0),
       video_capturer_(NULL) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(!client_jid_.empty());
+  DCHECK(!disconnect_callback_.is_null());
+}
+
+scoped_ptr<AudioCapturer> DesktopSessionProxy::CreateAudioCapturer(
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(!audio_capture_task_runner_.get());
+
+  audio_capture_task_runner_ = audio_task_runner;
+  return scoped_ptr<AudioCapturer>(new IpcAudioCapturer(this));
+}
+
+scoped_ptr<EventExecutor> DesktopSessionProxy::CreateEventExecutor(
+    scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+
+  return scoped_ptr<EventExecutor>(new IpcEventExecutor(this));
+}
+
+scoped_ptr<VideoFrameCapturer> DesktopSessionProxy::CreateVideoCapturer(
+    scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner) {
+  DCHECK(caller_task_runner_->BelongsToCurrentThread());
+  DCHECK(!video_capture_task_runner_.get());
+
+  video_capture_task_runner_ = capture_task_runner;
+  return scoped_ptr<VideoFrameCapturer>(new IpcVideoFrameCapturer(this));
 }
 
 bool DesktopSessionProxy::OnMessageReceived(const IPC::Message& message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DesktopSessionProxy, message)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_AudioPacket,
                         OnAudioPacket)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CaptureCompleted,
@@ skipping 18 matching lines @@
 
   VLOG(1) << "IPC: network <- desktop (" << peer_pid << ")";
 }
 
 void DesktopSessionProxy::OnChannelError() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   DetachFromDesktop();
 }
 
-void DesktopSessionProxy::Initialize(const std::string& client_jid,
-                                     const base::Closure& disconnect_callback) {
-  DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  DCHECK(client_jid_.empty());
-  DCHECK(!client_jid.empty());
-  DCHECK(disconnect_callback_.is_null());
-  DCHECK(!disconnect_callback.is_null());
-
-  client_jid_ = client_jid;
-  disconnect_callback_ = disconnect_callback;
-}
-
 bool DesktopSessionProxy::AttachToDesktop(
     IPC::PlatformFileForTransit desktop_process,
     IPC::PlatformFileForTransit desktop_pipe) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   DCHECK(!client_jid_.empty());
   DCHECK(!desktop_channel_);
   DCHECK(!disconnect_callback_.is_null());
 
 #if defined(OS_WIN)
   // On Windows: |desktop_process| is a valid handle, but |desktop_pipe| needs
@@ skipping 48 matching lines @@
 
   shared_buffers_.clear();
 
   // Generate fake responses to keep the video capturer in sync.
   while (pending_capture_frame_requests_) {
     --pending_capture_frame_requests_;
     PostCaptureCompleted(scoped_refptr<CaptureData>());
   }
 }
 
+void DesktopSessionProxy::StartAudioCapturer(IpcAudioCapturer* audio_capturer) {
+  DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(audio_capturer_ == NULL);
+
+  audio_capturer_ = audio_capturer;
+}
+
+void DesktopSessionProxy::StopAudioCapturer() {
+  DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
+
+  audio_capturer_ = NULL;
+}
+
+void DesktopSessionProxy::InvalidateRegion(const SkRegion& invalid_region) {
+  if (!caller_task_runner_->BelongsToCurrentThread()) {
+    caller_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DesktopSessionProxy::InvalidateRegion, this,
+                              invalid_region));
+    return;
+  }
+
+  std::vector<SkIRect> invalid_rects;
+  for (SkRegion::Iterator i(invalid_region); !i.done(); i.next())
+    invalid_rects.push_back(i.rect());
+
+  SendToDesktop(
+      new ChromotingNetworkDesktopMsg_InvalidateRegion(invalid_rects));
+}
+
+void DesktopSessionProxy::CaptureFrame() {
+  if (!caller_task_runner_->BelongsToCurrentThread()) {
+    caller_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&DesktopSessionProxy::CaptureFrame, this));
+    return;
+  }
+
+  ++pending_capture_frame_requests_;
+  SendToDesktop(new ChromotingNetworkDesktopMsg_CaptureFrame());
+}
+
+void DesktopSessionProxy::StartVideoCapturer(
+    IpcVideoFrameCapturer* video_capturer) {
+  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
+  DCHECK(video_capturer_ == NULL);
+
+  video_capturer_ = video_capturer;
+}
+
+void DesktopSessionProxy::StopVideoCapturer() {
+  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
+
+  video_capturer_ = NULL;
+}
+
 void DesktopSessionProxy::DisconnectSession() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Disconnect the client session if it hasn't been disconnected yet.
   disconnect_callback_.Run();
 }
 
 void DesktopSessionProxy::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
@@ skipping 34 matching lines @@
       new ChromotingNetworkDesktopMsg_InjectMouseEvent(serialized_event));
 }
 
 void DesktopSessionProxy::StartEventExecutor(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   client_clipboard_ = client_clipboard.Pass();
 }
 
-void DesktopSessionProxy::InvalidateRegion(const SkRegion& invalid_region) {
-  if (!caller_task_runner_->BelongsToCurrentThread()) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&DesktopSessionProxy::InvalidateRegion, this,
-                              invalid_region));
-    return;
-  }
-
-  std::vector<SkIRect> invalid_rects;
-  for (SkRegion::Iterator i(invalid_region); !i.done(); i.next())
-    invalid_rects.push_back(i.rect());
-
-  SendToDesktop(
-      new ChromotingNetworkDesktopMsg_InvalidateRegion(invalid_rects));
-}
-
-void DesktopSessionProxy::CaptureFrame() {
-  if (!caller_task_runner_->BelongsToCurrentThread()) {
-    caller_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&DesktopSessionProxy::CaptureFrame, this));
-    return;
-  }
-
-  ++pending_capture_frame_requests_;
-  SendToDesktop(new ChromotingNetworkDesktopMsg_CaptureFrame());
-}
-
-void DesktopSessionProxy::StartAudioCapturer(IpcAudioCapturer* audio_capturer) {
-  DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
-  DCHECK(audio_capturer_ == NULL);
-
-  audio_capturer_ = audio_capturer;
-}
-
-void DesktopSessionProxy::StopAudioCapturer() {
-  DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
-
-  audio_capturer_ = NULL;
-}
-
-void DesktopSessionProxy::StartVideoCapturer(
-    IpcVideoFrameCapturer* video_capturer) {
-  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
-  DCHECK(video_capturer_ == NULL);
-
-  video_capturer_ = video_capturer;
-}
-
-void DesktopSessionProxy::StopVideoCapturer() {
-  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
-
-  video_capturer_ = NULL;
-}
-
 DesktopSessionProxy::~DesktopSessionProxy() {
 }
 
 scoped_refptr<SharedBuffer> DesktopSessionProxy::GetSharedBuffer(int id) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   SharedBuffers::const_iterator i = shared_buffers_.find(id);
   if (i != shared_buffers_.end()) {
     return i->second;
   } else {
@@ skipping 97 matching lines @@
     const MouseCursorShape& cursor_shape) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
   PostCursorShape(
       scoped_ptr<MouseCursorShape>(new MouseCursorShape(cursor_shape)));
 }
 
 void DesktopSessionProxy::OnInjectClipboardEvent(
     const std::string& serialized_event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
-  protocol::ClipboardEvent event;
-  if (!event.ParseFromString(serialized_event)) {
-    LOG(ERROR) << "Failed to parse protocol::ClipboardEvent.";
-    return;
+  if (client_clipboard_) {
+    protocol::ClipboardEvent event;
+    if (!event.ParseFromString(serialized_event)) {
+      LOG(ERROR) << "Failed to parse protocol::ClipboardEvent.";
+      return;
+    }
+
+    client_clipboard_->InjectClipboardEvent(event);
   }
-
-  client_clipboard_->InjectClipboardEvent(event);
 }
 
 void DesktopSessionProxy::PostAudioPacket(scoped_ptr<AudioPacket> packet) {
   if (!audio_capture_task_runner_->BelongsToCurrentThread()) {
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionProxy::PostAudioPacket,
                               this, base::Passed(&packet)));
     return;
   }
 
@@ skipping 31 matching lines @@
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_channel_) {
     desktop_channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 }  // namespace remoting