Use webrtc::MouseCursorMonitor for cursor shapes

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/process/process_handle.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/capabilities.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/client_session.h"
 #include "remoting/host/client_session_control.h"
 #include "remoting/host/desktop_session_connector.h"
 #include "remoting/host/ipc_audio_capturer.h"
 #include "remoting/host/ipc_input_injector.h"
+#include "remoting/host/ipc_mouse_cursor_monitor.h"
 #include "remoting/host/ipc_screen_controls.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"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
+#include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif  // defined(OS_WIN)
 
 const bool kReadOnly = true;
 const char kSendInitialResolution[] = "sendInitialResolution";
 const char kRateLimitResizeRequests[] = "rateLimitResizeRequests";
 
@@ skipping 98 matching lines @@
 
   return scoped_ptr<ScreenControls>(new IpcScreenControls(this));
 }
 
 scoped_ptr<webrtc::ScreenCapturer> DesktopSessionProxy::CreateVideoCapturer() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   return scoped_ptr<webrtc::ScreenCapturer>(new IpcVideoFrameCapturer(this));
 }
 
+scoped_ptr<webrtc::MouseCursorMonitor>
+    DesktopSessionProxy::CreateMouseCursorMonitor() {
+  return scoped_ptr<webrtc::MouseCursorMonitor>(
+      new IpcMouseCursorMonitor(this));
+}
+
 std::string DesktopSessionProxy::GetCapabilities() const {
   std::string result = kRateLimitResizeRequests;
   // Ask the client to send its resolution unconditionally.
   if (virtual_terminal_)
     result = result + " " + kSendInitialResolution;
   return result;
 }
 
 void DesktopSessionProxy::SetCapabilities(const std::string& capabilities) {
   // Delay creation of the desktop session until the client screen resolution is
@@ skipping 19 matching lines @@
 
 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,
                         OnCaptureCompleted)
-    IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CursorShapeChanged,
-                        OnCursorShapeChanged)
+    IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_MouseCursor,
+                        OnMouseCursor)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_CreateSharedBuffer,
                         OnCreateSharedBuffer)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_ReleaseSharedBuffer,
                         OnReleaseSharedBuffer)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_InjectClipboardEvent,
                         OnInjectClipboardEvent)
     IPC_MESSAGE_HANDLER(ChromotingDesktopNetworkMsg_DisconnectSession,
                         DisconnectSession);
   IPC_END_MESSAGE_MAP()
 
@@ skipping 112 matching lines @@
   }
 }
 
 void DesktopSessionProxy::SetVideoCapturer(
     const base::WeakPtr<IpcVideoFrameCapturer> video_capturer) {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
 
   video_capturer_ = video_capturer;
 }
 
+void DesktopSessionProxy::SetMouseCursorMonitor(
+    const base::WeakPtr<IpcMouseCursorMonitor>& mouse_cursor_monitor) {
+  DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
+
+  mouse_cursor_monitor_ = mouse_cursor_monitor;
+}
+
 void DesktopSessionProxy::DisconnectSession() {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   // Disconnect the client session if it hasn't been disconnected yet.
   if (client_session_control_.get())
     client_session_control_->DisconnectSession();
 }
 
 void DesktopSessionProxy::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
@@ skipping 166 matching lines @@
   frame->set_dpi(serialized_frame.dpi);
 
   for (size_t i = 0; i < serialized_frame.dirty_region.size(); ++i) {
     frame->mutable_updated_region()->AddRect(serialized_frame.dirty_region[i]);
   }
 
   --pending_capture_frame_requests_;
   PostCaptureCompleted(frame.Pass());
 }
 
-void DesktopSessionProxy::OnCursorShapeChanged(
-    const webrtc::MouseCursorShape& cursor_shape) {
+void DesktopSessionProxy::OnMouseCursor(
+    const webrtc::MouseCursor& mouse_cursor) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
-  PostCursorShape(scoped_ptr<webrtc::MouseCursorShape>(
-      new webrtc::MouseCursorShape(cursor_shape)));
+  scoped_ptr<webrtc::MouseCursor> cursor(
+      webrtc::MouseCursor::CopyOf(mouse_cursor));
+  PostMouseCursor(cursor.Pass());
 }
 
 void DesktopSessionProxy::OnInjectClipboardEvent(
     const std::string& serialized_event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (client_clipboard_) {
     protocol::ClipboardEvent event;
     if (!event.ParseFromString(serialized_event)) {
       LOG(ERROR) << "Failed to parse protocol::ClipboardEvent.";
       return;
     }
 
     client_clipboard_->InjectClipboardEvent(event);
   }
 }
 
 void DesktopSessionProxy::PostCaptureCompleted(
     scoped_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   video_capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IpcVideoFrameCapturer::OnCaptureCompleted, video_capturer_,
                  base::Passed(&frame)));
 }
 
-void DesktopSessionProxy::PostCursorShape(
-    scoped_ptr<webrtc::MouseCursorShape> cursor_shape) {
+void DesktopSessionProxy::PostMouseCursor(
+    scoped_ptr<webrtc::MouseCursor> mouse_cursor) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   video_capture_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&IpcVideoFrameCapturer::OnCursorShapeChanged, video_capturer_,
-                 base::Passed(&cursor_shape)));
+      base::Bind(&IpcMouseCursorMonitor::OnMouseCursor, mouse_cursor_monitor_,
+                 base::Passed(&mouse_cursor)));
 }
 
 void DesktopSessionProxy::SendToDesktop(IPC::Message* message) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   if (desktop_channel_) {
     desktop_channel_->Send(message);
   } else {
     delete message;
   }
 }
 
 // static
 void DesktopSessionProxyTraits::Destruct(
     const DesktopSessionProxy* desktop_session_proxy) {
   desktop_session_proxy->caller_task_runner_->DeleteSoon(FROM_HERE,
                                                          desktop_session_proxy);
 }
 
 }  // namespace remoting