Converted VideoFrameCapturer callbacks into a VideoFrameCapturer::Delegate interface.

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"
@@ skipping 42 matching lines @@
   DCHECK(capturer_);
   DCHECK(cursor_stub_);
   DCHECK(video_stub_);
 
   capture_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, this));
 }
 
 // Public methods --------------------------------------------------------------
 
+void VideoScheduler::OnCaptureCompleted(
+    scoped_refptr<CaptureData> capture_data) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+
+  if (capture_data) {
+    base::TimeDelta capture_time = base::Time::Now() - capture_start_time_;
+    int capture_time_ms =
+        static_cast<int>(capture_time.InMilliseconds());
+    capture_data->set_capture_time_ms(capture_time_ms);
+    scheduler_.RecordCaptureTime(capture_time);
+
+    // The best way to get this value is by binding the sequence number to
+    // the callback when calling CaptureInvalidRects(). However the callback
+    // 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_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this, capture_data));
+}
+
+void VideoScheduler::OnCursorShapeChanged(
+    scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
+  DCHECK(capture_task_runner_->BelongsToCurrentThread());
+
+  network_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoScheduler::SendCursorShape, this,
+                            base::Passed(&cursor_shape)));
+}
+
 void VideoScheduler::Stop(const base::Closure& done_task) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(!done_task.is_null());
 
   // Clear stubs to prevent further updates reaching the client.
   cursor_stub_ = NULL;
   video_stub_ = NULL;
 
   capture_task_runner_->PostTask(FROM_HERE,
       base::Bind(&VideoScheduler::StopOnCaptureThread, this, done_task));
@@ skipping 32 matching lines @@
 
 VideoScheduler::~VideoScheduler() {
 }
 
 // Capturer thread -------------------------------------------------------------
 
 void VideoScheduler::StartOnCaptureThread() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // Start the capturer and let it notify us of cursor shape changes.
-  capturer_->Start(
-      base::Bind(&VideoScheduler::CursorShapeChangedCallback, this));
+  capturer_->Start(this);
 
   capture_timer_.reset(new base::OneShotTimer<VideoScheduler>());
 
   // Capture first frame immedately.
   CaptureNextFrame();
 }
 
 void VideoScheduler::StopOnCaptureThread(const base::Closure& done_task) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
@@ skipping 37 matching lines @@
 
   // At this point we are going to perform one capture so save the current time.
   pending_captures_++;
   DCHECK_LE(pending_captures_, kMaxPendingCaptures);
 
   // Before doing a capture schedule for the next one.
   ScheduleNextCapture();
 
   // And finally perform one capture.
   capture_start_time_ = base::Time::Now();
-  capturer_->CaptureInvalidRegion(
-      base::Bind(&VideoScheduler::CaptureDoneCallback, this));
-}
-
-void VideoScheduler::CaptureDoneCallback(
-    scoped_refptr<CaptureData> capture_data) {
-  DCHECK(capture_task_runner_->BelongsToCurrentThread());
-
-  if (capture_data) {
-    base::TimeDelta capture_time = base::Time::Now() - capture_start_time_;
-    int capture_time_ms =
-        static_cast<int>(capture_time.InMilliseconds());
-    capture_data->set_capture_time_ms(capture_time_ms);
-    scheduler_.RecordCaptureTime(capture_time);
-
-    // The best way to get this value is by binding the sequence number to
-    // the callback when calling CaptureInvalidRects(). However the callback
-    // 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_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this, capture_data));
-}
-
-void VideoScheduler::CursorShapeChangedCallback(
-    scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
-  DCHECK(capture_task_runner_->BelongsToCurrentThread());
-
-  network_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&VideoScheduler::SendCursorShape, this,
-                            base::Passed(&cursor_shape)));
+  capturer_->CaptureInvalidRegion();
 }
 
 void VideoScheduler::FrameCaptureCompleted() {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   // Decrement the pending capture count.
   pending_captures_--;
   DCHECK_GE(pending_captures_, 0);
 
   // If we've skipped a frame capture because too we had too many captures
@@ skipping 71 matching lines @@
     packet->set_encode_time_ms(encode_time_ms);
     scheduler_.RecordEncodeTime(encode_time);
   }
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting