[Chromoting] Initial plumbing for cursor shape.

remoting/host/screen_recorder.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/screen_recorder.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_proxy.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "remoting/base/capture_data.h"
 #include "remoting/proto/control.pb.h"
+#include "remoting/proto/internal.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/message_decoder.h"
 #include "remoting/protocol/util.h"
 
 using remoting::protocol::ConnectionToClient;
 
 namespace remoting {
 
@@ skipping 106 matching lines @@
 // Capturer thread -------------------------------------------------------------
 
 void ScreenRecorder::DoStart() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (is_recording()) {
     NOTREACHED() << "Record session already started.";
     return;
   }
 
-  capturer()->Start();
+  capturer()->Start(
+      base::Bind(&ScreenRecorder::CursorShapeChangedCallback, this));
+
   capture_timer_.reset(new base::OneShotTimer<ScreenRecorder>());
 
   // Capture first frame immedately.
   DoCapture();
 }
 
 void ScreenRecorder::StartCaptureTimer() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   capture_timer_->Start(FROM_HERE,
@@ skipping 51 matching lines @@
     // system doesn't allow this. Reading from the member variable is
     // accurate as long as capture is synchronous as the following statement
     // will obtain the most recent sequence number received.
     capture_data->set_client_sequence_number(sequence_number_);
   }
 
   encode_loop_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoEncode, this, capture_data));
 }
 
+void ScreenRecorder::CursorShapeChangedCallback(
+    scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
+  DCHECK_EQ(capture_loop_, MessageLoop::current());
+
+  if (!is_recording())
+    return;
+
+  network_loop_->PostTask(
+      FROM_HERE, base::Bind(&ScreenRecorder::DoSendCursorShape, this,
+                            base::Passed(cursor_shape.Pass())));
+}
+
 void ScreenRecorder::DoFinishOneRecording() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (!is_recording())
     return;
 
   // Decrement the number of recording in process since we have completed
   // one cycle.
   --recordings_;
   DCHECK_GE(recordings_, 0);
@@ skipping 47 matching lines @@
   //
   // After that a task is posted on encode thread to continue the stop
   // sequence.
   network_stopped_ = true;
 
   encode_loop_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoStopOnEncodeThread,
                             this, done_task));
 }
 
+void ScreenRecorder::DoSendCursorShape(
+    scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
+  DCHECK(network_loop_->BelongsToCurrentThread());
+
+  if (network_stopped_ || connections_.empty())
+    return;
+
+  // TODO(sergeyu): Currently we send the data only to the first
+  // connection. Send it to all connections if necessary.
+  connections_.front()->client_stub()->SetCursorShape(*cursor_shape);
+}
+
 // Encoder thread --------------------------------------------------------------
 
 void ScreenRecorder::DoEncode(
     scoped_refptr<CaptureData> capture_data) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   if (encoder_stopped_)
     return;
 
   // Early out if there's nothing to encode.
@@ skipping 39 matching lines @@
     packet->set_encode_time_ms(encode_time_ms);
     scheduler_.RecordEncodeTime(encode_time);
   }
 
   network_loop_->PostTask(
       FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
                             base::Passed(packet.Pass())));
 }
 
 }  // namespace remoting