Converted VideoFrameCapturer callbacks into a VideoFrameCapturer::Delegate interface.

remoting/host/video_frame_capturer_mac.mm

 // 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 <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
@@ skipping 95 matching lines @@
 
 // A class to perform video frame capturing for mac.
 class VideoFrameCapturerMac : public VideoFrameCapturer {
  public:
   VideoFrameCapturerMac();
   virtual ~VideoFrameCapturerMac();
 
   bool Init();
 
   // 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:
   void CaptureCursor();
 
   void GlBlitFast(const VideoFrameBuffer& buffer, const SkRegion& region);
   void GlBlitSlow(const VideoFrameBuffer& buffer);
   void CgBlitPreLion(const VideoFrameBuffer& buffer, const SkRegion& region);
   void CgBlitPostLion(const VideoFrameBuffer& buffer, const SkRegion& region);
-  void CaptureRegion(const SkRegion& region,
-                     const CaptureCompletedCallback& callback);
 
   // Called when the screen configuration is changed.
   void ScreenConfigurationChanged();
 
   void ScreenRefresh(CGRectCount count, const CGRect *rect_array);
   void ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
                         size_t count,
                         const CGRect *rect_array);
   void DisplaysReconfigured(CGDirectDisplayID display,
                             CGDisplayChangeSummaryFlags flags);
   static void ScreenRefreshCallback(CGRectCount count,
                                     const CGRect *rect_array,
                                     void *user_parameter);
   static void ScreenUpdateMoveCallback(CGScreenUpdateMoveDelta delta,
                                        size_t count,
                                        const CGRect *rect_array,
                                        void *user_parameter);
   static void DisplaysReconfiguredCallback(CGDirectDisplayID display,
                                            CGDisplayChangeSummaryFlags flags,
                                            void *user_parameter);
 
   void ReleaseBuffers();
 
+  Delegate* delegate_;
+
   CGLContextObj cgl_context_;
   static const int kNumBuffers = 2;
   ScopedPixelBufferObject pixel_buffer_object_;
   VideoFrameBuffer buffers_[kNumBuffers];
 
   // Current display configuration.
   std::vector<CGDirectDisplayID> display_ids_;
   SkIRect desktop_bounds_;
 
   // 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_;
-
   // Image of the last cursor that we sent to the client.
   base::mac::ScopedCFTypeRef<CGImageRef> current_cursor_;
 
   // The current buffer with valid data for reading.
   int current_buffer_;
 
   // The previous buffer into which we captured, or NULL for the first capture
   // for a particular screen resolution.
   uint8* last_buffer_;
 
@@ skipping 18 matching lines @@
   CGDisplayBaseAddressFunc cg_display_base_address_;
   CGDisplayBytesPerRowFunc cg_display_bytes_per_row_;
   CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_;
   base::ScopedNativeLibrary opengl_library_;
   CGLSetFullScreenFunc cgl_set_full_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerMac);
 };
 
 VideoFrameCapturerMac::VideoFrameCapturerMac()
-    : cgl_context_(NULL),
+    : delegate_(NULL),
+      cgl_context_(NULL),
       current_buffer_(0),
       last_buffer_(NULL),
       pixel_format_(media::VideoFrame::RGB32),
       display_configuration_capture_event_(false, true),
       power_assertion_id_display_(kIOPMNullAssertionID),
       power_assertion_id_user_(kIOPMNullAssertionID),
       cg_display_base_address_(NULL),
       cg_display_bytes_per_row_(NULL),
       cg_display_bits_per_pixel_(NULL),
       cgl_set_full_screen_(NULL)
@@ skipping 45 matching lines @@
     cgl_context_ = NULL;
   }
   // The buffers might be in use by the encoder, so don't delete them here.
   // Instead, mark them as "needs update"; next time the buffers are used by
   // the capturer, they will be recreated if necessary.
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
 }
 
-void VideoFrameCapturerMac::Start(const CursorShapeChangedCallback& callback) {
-  cursor_shape_changed_callback_ = callback;
+void VideoFrameCapturerMac::Start(Delegate* delegate) {
+  DCHECK(delegate_ == NULL);
+
+  delegate_ = delegate;
 
   // Create power management assertions to wake the display and prevent it from
   // going to sleep on user idle.
   // TODO(jamiewalch): Use IOPMAssertionDeclareUserActivity on 10.7.3 and above
   //                   instead of the following two assertions.
   IOPMAssertionCreateWithName(kIOPMAssertionTypeNoDisplaySleep,
                               kIOPMAssertionLevelOn,
                               CFSTR("Chrome Remote Desktop connection active"),
                               &power_assertion_id_display_);
   // This assertion ensures that the display is woken up if it  already asleep
@@ skipping 16 matching lines @@
 }
 
 media::VideoFrame::Format VideoFrameCapturerMac::pixel_format() const {
   return pixel_format_;
 }
 
 void VideoFrameCapturerMac::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerMac::CaptureInvalidRegion(
-    const CaptureCompletedCallback& callback) {
+void VideoFrameCapturerMac::CaptureInvalidRegion() {

[simonmorris, 2012/11/07 20:35:21]

DCHECK(delegate_ != NULL) ?

[alexeypa (please no reviews), 2012/11/07 20:54:41]

Same as before.

   // Only allow captures when the display configuration is not occurring.
   scoped_refptr<CaptureData> data;
 
   // Critical section shared with DisplaysReconfigured(...).
   CHECK(display_configuration_capture_event_.TimedWait(
       base::TimeDelta::FromSeconds(kDisplayReconfigurationTimeoutInSeconds)));
   SkRegion region;
   helper_.SwapInvalidRegion(&region);
   VideoFrameBuffer& current_buffer = buffers_[current_buffer_];
   current_buffer.Update(SkISize::Make(desktop_bounds_.width(),
@@ skipping 29 matching lines @@
   data = new CaptureData(planes, current_buffer.size(), pixel_format());
   data->set_dpi(current_buffer.dpi());
   data->mutable_dirty_region() = region;
 
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
   helper_.set_size_most_recent(data->size());
   display_configuration_capture_event_.Signal();
 
   CaptureCursor();
 
-  callback.Run(data);
+  delegate->OnCaptureCompleted(data);
 }
 
 void VideoFrameCapturerMac::CaptureCursor() {

[simonmorris, 2012/11/07 20:35:21]

Return if delegate_ is NULL?

[alexeypa (please no reviews), 2012/11/07 20:54:41]

|delegate_| cannot be NULL. That check was a development artifact of cursor
shape feature.

-  if (cursor_shape_changed_callback_.is_null()) {
-    return;
-    }
-
   NSCursor* cursor = [NSCursor currentSystemCursor];
   if (cursor == nil) {
     return;
   }
 
   NSImage* nsimage = [cursor image];
   NSPoint hotspot = [cursor hotSpot];
   NSSize size = [nsimage size];
   CGImageRef image = [nsimage CGImageForProposedRect:NULL
                                              context:nil
@@ skipping 55 matching lines @@
   cursor_proto->mutable_data()->resize(data_size);
   uint8* cursor_tgt_data = const_cast<uint8*>(reinterpret_cast<const uint8*>(
       cursor_proto->mutable_data()->data()));
 
   memcpy(cursor_tgt_data, cursor_src_data, data_size);
 
   cursor_proto->set_width(size.width);
   cursor_proto->set_height(size.height);
   cursor_proto->set_hotspot_x(hotspot.x);
   cursor_proto->set_hotspot_y(hotspot.y);
-  cursor_shape_changed_callback_.Run(cursor_proto.Pass());
+  delegate_->OnCursorShapeChanged(cursor_proto.Pass());
 
   // Record the last cursor image that we sent.
   current_cursor_.reset(CGImageCreateCopy(image));
 }
 
 void VideoFrameCapturerMac::GlBlitFast(const VideoFrameBuffer& buffer,
                                        const SkRegion& region) {
   const int buffer_height = buffer.size().height();
   const int buffer_width = buffer.size().width();
 
@@ skipping 371 matching lines @@
 VideoFrameCapturer* VideoFrameCapturer::Create() {
   VideoFrameCapturerMac* capturer = new VideoFrameCapturerMac();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting