Use webrtc::MouseCursorMonitor for cursor shapes

remoting/host/video_scheduler.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/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/protocol/message_decoder.h"
 #include "remoting/protocol/util.h"
 #include "remoting/protocol/video_stub.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/mouse_cursor_shape.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer.h"
 
 namespace remoting {
 
 // Maximum number of frames that can be processed simultaneously.
 // TODO(hclam): Move this value to CaptureScheduler.
 static const int kMaxPendingFrames = 2;
 
 VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
     scoped_ptr<webrtc::ScreenCapturer> capturer,
+    scoped_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
       network_task_runner_(network_task_runner),
       capturer_(capturer.Pass()),
+      mouse_cursor_monitor_(mouse_cursor_monitor.Pass()),
       encoder_(encoder.Pass()),
       cursor_stub_(cursor_stub),
       video_stub_(video_stub),
       pending_frames_(0),
       capture_pending_(false),
       did_skip_frame_(false),
       is_paused_(false),
       sequence_number_(0) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(capturer_);
@@ skipping 24 matching lines @@
       FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this,
                             base::Passed(&owned_frame), sequence_number_));
 
   // If a frame was skipped, try to capture it again.
   if (did_skip_frame_) {
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::CaptureNextFrame, this));
   }
 }
 
-void VideoScheduler::OnCursorShapeChanged(
-    webrtc::MouseCursorShape* cursor_shape) {
+void VideoScheduler::OnMouseCursor(webrtc::MouseCursor* cursor) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<webrtc::MouseCursorShape> owned_cursor(cursor_shape);
+  scoped_ptr<webrtc::MouseCursor> owned_cursor(cursor);
 
   // Do nothing if the scheduler is being stopped.
   if (!capturer_)
     return;
 
   scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
       new protocol::CursorShapeInfo());
-  cursor_proto->set_width(cursor_shape->size.width());
-  cursor_proto->set_height(cursor_shape->size.height());
-  cursor_proto->set_hotspot_x(cursor_shape->hotspot.x());
-  cursor_proto->set_hotspot_y(cursor_shape->hotspot.y());
-  cursor_proto->set_data(cursor_shape->data);
+  cursor_proto->set_width(cursor->image().size().width());
+  cursor_proto->set_height(cursor->image().size().height());
+  cursor_proto->set_hotspot_x(cursor->hotspot().x());
+  cursor_proto->set_hotspot_y(cursor->hotspot().y());
+
+  std::string data;
+  uint8_t* current_row = cursor->image().data();
+  for (int y = 0; y < cursor->image().size().height(); ++y) {
+    data.append(current_row,
+                current_row + cursor->image().size().width() *
+                    webrtc::DesktopFrame::kBytesPerPixel);
+    current_row += cursor->image().stride();
+  }
+  cursor_proto->set_data(data);

[Sergey Ulanov, 2013/12/03 21:47:28]

Insted of building data and then copying it to the cursor_proto you can build it
directly inside cursor_proto by calling
cursor_proto->mutable_data()->append(....) in the loop.

[dcaiafa, 2013/12/10 01:32:03]

Done.

 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendCursorShape, this,
                             base::Passed(&cursor_proto)));
 }
 
+void VideoScheduler::OnMouseCursorPosition(
+    webrtc::MouseCursorMonitor::CursorState state,
+    const webrtc::DesktopVector& position) {
+  // We're not subscribing to mouse position changes.
+  NOTREACHED();
+}
+
 void VideoScheduler::Start() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
 }
 
 void VideoScheduler::Stop() {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
@@ skipping 38 matching lines @@
 
 VideoScheduler::~VideoScheduler() {
 }
 
 // Capturer thread -------------------------------------------------------------
 
 void VideoScheduler::StartOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DCHECK(!capture_timer_);
 
-  // Start the capturer and let it notify us if cursor shape changes.
-  capturer_->SetMouseShapeObserver(this);
+  // Start mouse cursor monitor.
+  mouse_cursor_monitor_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
+
+  // Start the capturer.
   capturer_->Start(this);
 
   capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
 
   // Capture first frame immedately.
   CaptureNextFrame();
 }
 
 void VideoScheduler::StopOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
@@ skipping 34 matching lines @@
 
   // At this point we are going to perform one capture so save the current time.
   pending_frames_++;
   DCHECK_LE(pending_frames_, kMaxPendingFrames);
 
   // Before doing a capture schedule for the next one.
   ScheduleNextCapture();
 
   capture_pending_ = true;
 
+  // Capture the mouse shape.
+  mouse_cursor_monitor_->Capture();
+
   // And finally perform one capture.
   capturer_->Capture(webrtc::DesktopRegion());
 }
 
 void VideoScheduler::FrameCaptureCompleted() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // Decrement the pending capture count.
   pending_frames_--;
   DCHECK_GE(pending_frames_, 0);
@@ skipping 63 matching lines @@
   frame.reset();
 
   scheduler_.RecordEncodeTime(
       base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting