Converted VideoFrameCapturer callbacks into a VideoFrameCapturer::Delegate interface.

remoting/host/video_frame_capturer_fake.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_frame_capturer_fake.h"
 
 #include "remoting/base/capture_data.h"
 
 namespace remoting {
 
@@ skipping 21 matching lines @@
       box_speed_x_(kSpeed),
       box_speed_y_(kSpeed),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32) {
   ScreenConfigurationChanged();
 }
 
 VideoFrameCapturerFake::~VideoFrameCapturerFake() {
 }
 
-void VideoFrameCapturerFake::Start(const CursorShapeChangedCallback& callback) {
+void VideoFrameCapturerFake::Start(Delegate* delegate) {
+  delegate_ = delegate;
 }
 
 void VideoFrameCapturerFake::Stop() {
 }
 
 media::VideoFrame::Format VideoFrameCapturerFake::pixel_format() const {
   return pixel_format_;
 }
 
 void VideoFrameCapturerFake::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerFake::CaptureInvalidRegion(
-    const CaptureCompletedCallback& callback) {
+void VideoFrameCapturerFake::CaptureInvalidRegion() {
   GenerateImage();
   helper_.InvalidateScreen(size_);
 
   SkRegion invalid_region;
   helper_.SwapInvalidRegion(&invalid_region);
 
   DataPlanes planes;
   planes.data[0] = buffers_[current_buffer_].get();
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
   planes.strides[0] = bytes_per_row_;
 
   scoped_refptr<CaptureData> capture_data(new CaptureData(planes,
                                                           size_,
                                                           pixel_format_));
   capture_data->mutable_dirty_region() = invalid_region;
 
   helper_.set_size_most_recent(capture_data->size());
 
-  callback.Run(capture_data);
+  delegate_->OnCaptureCompleted(capture_data);
 }
 
 const SkISize& VideoFrameCapturerFake::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
 void VideoFrameCapturerFake::GenerateImage() {
   memset(buffers_[current_buffer_].get(), 0xff,
          size_.width() * size_.height() * kBytesPerPixel);
 
@@ skipping 32 matching lines @@
   pixel_format_ = media::VideoFrame::RGB32;
 
   // Create memory for the buffers.
   int buffer_size = size_.height() * bytes_per_row_;
   for (int i = 0; i < kNumBuffers; i++) {
     buffers_[i].reset(new uint8[buffer_size]);
   }
 }
 
 }  // namespace remoting