Converted VideoFrameCapturer callbacks into a VideoFrameCapturer::Delegate interface.

remoting/host/video_frame_capturer_win.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.h"
 
 #include <windows.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
@@ skipping 30 matching lines @@
 // VideoFrameCapturerWin captures 32bit RGB using GDI.
 //
 // VideoFrameCapturerWin is double-buffered as required by VideoFrameCapturer.
 // See remoting/host/video_frame_capturer.h.
 class VideoFrameCapturerWin : public VideoFrameCapturer {
  public:
   VideoFrameCapturerWin();
   virtual ~VideoFrameCapturerWin();
 
   // Overridden from VideoFrameCapturer:
-  virtual void Start(const CursorShapeChangedCallback& callback) OVERRIDE;
+  virtual void Start(Delegate* delegate) OVERRIDE;
   virtual void Stop() OVERRIDE;
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE;
-  virtual void CaptureInvalidRegion(
-      const CaptureCompletedCallback& callback) OVERRIDE;
+  virtual void CaptureInvalidRegion() OVERRIDE;
   virtual const SkISize& size_most_recent() const OVERRIDE;
 
  private:
   struct VideoFrameBuffer {
     VideoFrameBuffer();
 
     void* data;
     SkISize size;
     int bytes_per_pixel;
     int bytes_per_row;
     int resource_generation;
   };
 
   // Make sure that the device contexts and the current buffer match the screen
   // configuration.
   void PrepareCaptureResources();
 
   // Allocates the specified capture buffer using the current device contexts
   // and desktop dimensions, releasing any pre-existing buffer.
   void AllocateBuffer(int buffer_index, int resource_generation);
 
   // Compares the most recently captured screen contents with the previous
   // contents reported to the caller, to determine the dirty region.
   void CalculateInvalidRegion();
 
-  // Creates a CaptureData instance wrapping the current framebuffer and calls
-  // |callback| with it.
-  void CaptureRegion(const SkRegion& region,
-                     const CaptureCompletedCallback& callback);
+  // Creates a CaptureData instance wrapping the current framebuffer and
+  // notifies |delegate_|.
+  void CaptureRegion(const SkRegion& region);
 
   // Captures the current screen contents into the next available framebuffer.
   void CaptureImage();
 
   // Expand the cursor shape to add a white outline for visibility against
   // dark backgrounds.
   void AddCursorOutline(int width, int height, uint32* dst);
 
   // Capture the current cursor shape.
   void CaptureCursor();
 
+  Delegate* delegate_;
+
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   VideoFrameCapturerHelper helper_;
 
-  // Callback notified whenever the cursor shape is changed.
-  CursorShapeChangedCallback cursor_shape_changed_callback_;
-
   // Snapshot of the last cursor bitmap we sent to the client. This is used
   // to diff against the current cursor so we only send a cursor-change
   // message when the shape has changed.
   scoped_array<uint8> last_cursor_;
   SkISize last_cursor_size_;
 
   // There are two buffers for the screen images, as required by Capturer.
   static const int kNumBuffers = 2;
   VideoFrameBuffer buffers_[kNumBuffers];
 
@@ skipping 30 matching lines @@
 
 VideoFrameCapturerWin::VideoFrameBuffer::VideoFrameBuffer()
     : data(NULL),
       size(SkISize::Make(0, 0)),
       bytes_per_pixel(0),
       bytes_per_row(0),
       resource_generation(0) {
 }
 
 VideoFrameCapturerWin::VideoFrameCapturerWin()
-    : last_cursor_size_(SkISize::Make(0, 0)),
+    : delegate_(NULL),
+      last_cursor_size_(SkISize::Make(0, 0)),
       desktop_dc_rect_(SkIRect::MakeEmpty()),
       resource_generation_(0),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32),
       composition_func_(NULL) {
 }
 
 VideoFrameCapturerWin::~VideoFrameCapturerWin() {
 }
 
 media::VideoFrame::Format VideoFrameCapturerWin::pixel_format() const {
   return pixel_format_;
 }
 
 void VideoFrameCapturerWin::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerWin::CaptureInvalidRegion(
-    const CaptureCompletedCallback& callback) {
+void VideoFrameCapturerWin::CaptureInvalidRegion() {
   // Force the system to power-up display hardware, if it has been suspended.
   SetThreadExecutionState(ES_DISPLAY_REQUIRED);
 
   // Perform the capture.
   CalculateInvalidRegion();
   SkRegion invalid_region;
   helper_.SwapInvalidRegion(&invalid_region);
-  CaptureRegion(invalid_region, callback);
+  CaptureRegion(invalid_region);
 
   // Check for cursor shape update.
   CaptureCursor();
 }
 
 const SkISize& VideoFrameCapturerWin::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
-void VideoFrameCapturerWin::Start(
-    const CursorShapeChangedCallback& callback) {
-  cursor_shape_changed_callback_ = callback;
+void VideoFrameCapturerWin::Start(Delegate* delegate) {
+  DCHECK(delegate_ == NULL);
+
+  delegate_ = delegate;
 
   // Load dwmapi.dll dynamically since it is not available on XP.
   if (!dwmapi_library_.is_valid()) {
     FilePath path(base::GetNativeLibraryName(UTF8ToUTF16(kDwmapiLibraryName)));
     dwmapi_library_.Reset(base::LoadNativeLibrary(path, NULL));
   }
 
   if (dwmapi_library_.is_valid() && composition_func_ == NULL) {
     composition_func_ = static_cast<DwmEnableCompositionFunc>(
         dwmapi_library_.GetFunctionPointer("DwmEnableComposition"));
   }
 
   // Vote to disable Aero composited desktop effects while capturing. Windows
   // will restore Aero automatically if the process exits. This has no effect
   // under Windows 8 or higher.  See crbug.com/124018.
   if (composition_func_ != NULL) {
     (*composition_func_)(DWM_EC_DISABLECOMPOSITION);
   }
 }
 
 void VideoFrameCapturerWin::Stop() {
   // Restore Aero.
   if (composition_func_ != NULL) {
     (*composition_func_)(DWM_EC_ENABLECOMPOSITION);
   }
+
+  delegate_ = NULL;
 }
 
 void VideoFrameCapturerWin::PrepareCaptureResources() {
   // Switch to the desktop receiving user input if different from the current
   // one.
   scoped_ptr<Desktop> input_desktop = Desktop::GetInputDesktop();
   if (input_desktop.get() != NULL && !desktop_.IsSame(*input_desktop)) {
     // Release GDI resources otherwise SetThreadDesktop will fail.
     desktop_dc_.reset();
     memory_dc_.Set(NULL);
@@ skipping 110 matching lines @@
     differ_.reset(new Differ(current.size.width(), current.size.height(),
       current.bytes_per_pixel, current.bytes_per_row));
   }
 
   SkRegion region;
   differ_->CalcDirtyRegion(prev.data, current.data, &region);
 
   InvalidateRegion(region);
 }
 
-void VideoFrameCapturerWin::CaptureRegion(
-    const SkRegion& region,
-    const CaptureCompletedCallback& callback) {
+void VideoFrameCapturerWin::CaptureRegion(const SkRegion& region) {
   const VideoFrameBuffer& buffer = buffers_[current_buffer_];
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
 
   DataPlanes planes;
   planes.data[0] = static_cast<uint8*>(buffer.data);
   planes.strides[0] = buffer.bytes_per_row;
 
   scoped_refptr<CaptureData> data(new CaptureData(planes,
                                                   buffer.size,
                                                   pixel_format_));
   data->mutable_dirty_region() = region;
 
   helper_.set_size_most_recent(data->size());
 
-  callback.Run(data);
+  delegate_->OnCaptureCompleted(data);
 }
 
 void VideoFrameCapturerWin::CaptureImage() {
   // Make sure the GDI capture resources are up-to-date.
   PrepareCaptureResources();
 
   // Select the target bitmap into the memory dc.
   SelectObject(memory_dc_, target_bitmap_[current_buffer_]);
 
   // And then copy the rect from desktop to memory.
@@ skipping 176 matching lines @@
   cursor_proto->set_width(width);
   cursor_proto->set_height(height);
   cursor_proto->set_hotspot_x(hotspot_x);
   cursor_proto->set_hotspot_y(hotspot_y);
 
   // Record the last cursor image that we sent to the client.
   last_cursor_.reset(new uint8[data_size]);
   memcpy(last_cursor_.get(), cursor_dst_data, data_size);
   last_cursor_size_ = SkISize::Make(width, height);
 
-  cursor_shape_changed_callback_.Run(cursor_proto.Pass());
+  delegate_->OnCursorShapeChanged(cursor_proto.Pass());
 }
 
 }  // namespace
 
 // static
 VideoFrameCapturer* VideoFrameCapturer::Create() {
   return new VideoFrameCapturerWin();
 }
 
 }  // namespace remoting