[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"
@@ skipping 124 matching lines @@
 // Capturer thread -------------------------------------------------------------
 
 void ScreenRecorder::DoStart() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
   if (is_recording()) {
     NOTREACHED() << "Record session already started.";
     return;
   }
 
+  capturer()->SetCursorShapeChangedCallback(
+      base::Bind(&ScreenRecorder::CursorShapeChangedCallback, this));

[Wez, 2012/05/16 00:20:04]

nit: Could we do this in the ScreenRecorder's constructor?

[garykac, 2012/05/22 00:42:03]

Wrong thread.

+
   capturer()->Start();
   capture_timer_.reset(new base::OneShotTimer<ScreenRecorder>());
 
   // Capture first frame immedately.
   DoCapture();
 }
 
 void ScreenRecorder::StartCaptureTimer() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
 
@@ skipping 52 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_refptr<CursorShapeData> cursor_data) {
+  DCHECK_EQ(capture_loop_, MessageLoop::current());
+
+  if (!is_recording())
+    return;
+
+  encode_loop_->PostTask(
+      FROM_HERE, base::Bind(&ScreenRecorder::DoEncodeCursor,
+                            this, cursor_data));
+}
+
 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 73 matching lines @@
                               this, base::Passed(packet.Pass())));
     return;
   }
 
   encode_start_time_ = base::Time::Now();
   encoder()->Encode(
       capture_data, false,
       base::Bind(&ScreenRecorder::EncodedDataAvailableCallback, this));
 }
 
+void ScreenRecorder::DoEncodeCursor(scoped_refptr<CursorShapeData> cursor) {
+  DCHECK_EQ(encode_loop_, MessageLoop::current());
+
+  scoped_ptr<VideoPacket> packet(new VideoPacket());
+  packet->set_flags(VideoPacket::CURSOR_SHAPE);
+
+  CursorShapeInfo* info = packet->mutable_cursor_shape();
+  info->set_width(16);
+  info->set_height(16);
+  info->set_hotspot_x(0);
+  info->set_hotspot_y(0);
+
+  packet->mutable_data()->resize(16 * 16 * 4);
+  uint8* data = const_cast<uint8*>(reinterpret_cast<const uint8*>(
+      packet->mutable_data()->data()));
+  // TODO(garykac) Copy real cursor data into packet.

[Wez, 2012/05/16 00:20:04]

Copying the data should be implemented in this CL, it seems?

[garykac, 2012/05/22 00:42:03]

Done.

+  for (int y = 0; y < 16; y++) {
+    for (int x = 0; x < 16; x++) {
+      *data++ = 0xff;
+      *data++ = 0xff;
+      *data++ = 0xff;
+      *data++ = 0xff;
+    }
+  }
+
+  network_loop_->PostTask(
+      FROM_HERE, base::Bind(&ScreenRecorder::DoSendVideoPacket, this,
+                            base::Passed(packet.Pass())));
+}
+
 void ScreenRecorder::DoStopOnEncodeThread(const base::Closure& done_task) {
   DCHECK_EQ(encode_loop_, MessageLoop::current());
 
   encoder_stopped_ = true;
 
   // When this method is being executed there are no more tasks on encode thread
   // for this object. We can then post a task to capture thread to finish the
   // stop sequence.
   capture_loop_->PostTask(FROM_HERE, done_task);
 }
@@ skipping 13 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