Use webrtc::MouseCursorMonitor for cursor shapes

remoting/host/desktop_session_agent.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_agent.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/ipc_util.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/host/screen_controls.h"
 #include "remoting/host/screen_resolution.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
+#include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "third_party/webrtc/modules/desktop_capture/shared_memory.h"
 
 namespace remoting {
 
 namespace {
 
 // Routes local clipboard events though the IPC channel to the network process.
 class DesktopSesssionClipboardStub : public protocol::ClipboardStub {
  public:
   explicit DesktopSesssionClipboardStub(
@@ skipping 244 matching lines @@
       new DesktopSesssionClipboardStub(this));
   input_injector_->Start(clipboard_stub.Pass());
 
   // Start the audio capturer.
   if (delegate_->desktop_environment_factory().SupportsAudioCapture()) {
     audio_capturer_ = desktop_environment_->CreateAudioCapturer();
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
   }
 
-  // Start the video capturer.
+  // Start the video capturer and mouse cursor monitor.
   video_capturer_ = desktop_environment_->CreateVideoCapturer();
+  mouse_cursor_monitor_ = desktop_environment_->CreateMouseCursorMonitor();
   video_capture_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this));
+      FROM_HERE, base::Bind(
+          &DesktopSessionAgent::StartVideoCapturerAndMouseMonitor, this));
 }
 
 void DesktopSessionAgent::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
 
   last_frame_.reset(frame);
 
   current_size_ = frame->size();
 
   // Serialize webrtc::DesktopFrame.
   SerializedDesktopFrame serialized_frame;
   serialized_frame.shared_buffer_id = frame->shared_memory()->id();
   serialized_frame.bytes_per_row = frame->stride();
   serialized_frame.dimensions = frame->size();
   serialized_frame.capture_time_ms = frame->capture_time_ms();
   serialized_frame.dpi = frame->dpi();
   for (webrtc::DesktopRegion::Iterator i(frame->updated_region());
        !i.IsAtEnd(); i.Advance()) {
     serialized_frame.dirty_region.push_back(i.rect());
   }
 
   SendToNetwork(
       new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_frame));
 }
 
-void DesktopSessionAgent::OnCursorShapeChanged(
-    webrtc::MouseCursorShape* cursor_shape) {
+void DesktopSessionAgent::OnMouseCursor(webrtc::MouseCursor* cursor) {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<webrtc::MouseCursorShape> owned_cursor(cursor_shape);
+  scoped_ptr<webrtc::MouseCursor> owned_cursor(cursor);
 
-  SendToNetwork(new ChromotingDesktopNetworkMsg_CursorShapeChanged(
-      *cursor_shape));
+  SerializedMouseCursor serialized_cursor;
+  serialized_cursor.size = cursor->image().size();
+  serialized_cursor.hotspot = cursor->hotspot();
+
+  uint8_t* current_row = cursor->image().data();
+  for (int y = 0; y < cursor->image().size().height(); ++y) {
+    serialized_cursor.data.append(
+        current_row,
+        current_row + cursor->image().size().width() *
+            webrtc::DesktopFrame::kBytesPerPixel);
+    current_row += cursor->image().stride();
+  }
+
+  SendToNetwork(
+      new ChromotingDesktopNetworkMsg_MouseCursor(serialized_cursor));
+}
+
+void DesktopSessionAgent::OnMouseCursorPosition(
+    webrtc::MouseCursorMonitor::CursorState state,
+    const webrtc::DesktopVector& position) {
+  // We're not subscribing to mouse position changes.
+  NOTREACHED();
 }
 
 void DesktopSessionAgent::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   std::string serialized_event;
   if (!event.SerializeToString(&serialized_event)) {
     LOG(ERROR) << "Failed to serialize protocol::ClipboardEvent.";
     return;
@@ skipping 55 matching lines @@
     desktop_environment_.reset();
     input_injector_.reset();
     screen_controls_.reset();
 
     // Stop the audio capturer.
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StopAudioCapturer, this));
 
     // Stop the video capturer.
     video_capture_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&DesktopSessionAgent::StopVideoCapturer, this));
+        FROM_HERE, base::Bind(
+            &DesktopSessionAgent::StopVideoCapturerAndMouseMonitor, this));
   }
 }
 
 void DesktopSessionAgent::OnCaptureFrame() {
   if (!video_capture_task_runner_->BelongsToCurrentThread()) {
     video_capture_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DesktopSessionAgent::OnCaptureFrame, this));
     return;
   }
 
+  mouse_cursor_monitor_->Capture();
+
   // webrtc::ScreenCapturer supports a very few (currently 2) outstanding
   // capture requests. The requests are serialized on
   // |video_capture_task_runner()| task runner. If the client issues more
   // requests, pixel data in captured frames will likely be corrupted but
   // stability of webrtc::ScreenCapturer will not be affected.
   video_capturer_->Capture(webrtc::DesktopRegion());
 }
 
 void DesktopSessionAgent::OnInjectClipboardEvent(
     const std::string& serialized_event) {
@@ skipping 76 matching lines @@
                                       this));
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
-void DesktopSessionAgent::StartVideoCapturer() {
+void DesktopSessionAgent::StartVideoCapturerAndMouseMonitor() {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
 
   if (video_capturer_) {
-    video_capturer_->SetMouseShapeObserver(this);
     video_capturer_->Start(this);
   }
+
+  if (mouse_cursor_monitor_) {
+    mouse_cursor_monitor_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
+  }
 }
 
-void DesktopSessionAgent::StopVideoCapturer() {
+void DesktopSessionAgent::StopVideoCapturerAndMouseMonitor() {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
 
   video_capturer_.reset();
   last_frame_.reset();
+  mouse_cursor_monitor_.reset();
 
   // Video capturer must delete all buffers.
   DCHECK_EQ(shared_buffers_, 0);
 }
 
 void DesktopSessionAgent::OnSharedBufferDeleted(int id) {
   DCHECK(video_capture_task_runner_->BelongsToCurrentThread());
   DCHECK(id != 0);
 
   shared_buffers_--;
   DCHECK_GE(shared_buffers_, 0);
   SendToNetwork(new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(id));
 }
 
 void DesktopSessionAgent::CloseDesktopPipeHandle() {
   if (!(desktop_pipe_ == IPC::InvalidPlatformFileForTransit())) {
 #if defined(OS_WIN)
     base::ClosePlatformFile(desktop_pipe_);
 #elif defined(OS_POSIX)
     base::ClosePlatformFile(desktop_pipe_.fd);
 #else  // !defined(OS_POSIX)
 #error Unsupported platform.
 #endif  // !defined(OS_POSIX)
 
     desktop_pipe_ = IPC::InvalidPlatformFileForTransit();
   }
 }
 
 }  // namespace remoting