Converted VideoFrameCapturer callbacks into a VideoFrameCapturer::Delegate interface.

remoting/host/video_frame_capturer_linux.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 <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
@@ skipping 65 matching lines @@
 
 // A class to perform video frame capturing for Linux.
 class VideoFrameCapturerLinux : public VideoFrameCapturer {
  public:
   VideoFrameCapturerLinux();
   virtual ~VideoFrameCapturerLinux();
 
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   // Capturer interface.
-  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 InitXDamage();
 
   // Read and handle all currently-pending XEvents.
   // In the DAMAGE case, process the XDamage events and store the resulting
   // damage rectangles in the VideoFrameCapturerHelper.
   // In all cases, call ScreenConfigurationChanged() in response to any
   // ConfigNotify events.
   void ProcessPendingXEvents();
 
   // Capture screen pixels, and return the data in a new CaptureData object,
   // to be freed by the caller.
   // In the DAMAGE case, the VideoFrameCapturerHelper already holds the list of
   // invalid rectangles from ProcessPendingXEvents().
   // In the non-DAMAGE case, this captures the whole screen, then calculates
   // some invalid rectangles that include any differences between this and the
   // previous capture.
   CaptureData* CaptureFrame();
 
-  // Capture the cursor image and call the CursorShapeChangedCallback if it
-  // has been set (using SetCursorShapeChangedCallback).
+  // Capture the cursor image and notify the delegate if it was captured.
   void CaptureCursor();
 
   // Called when the screen configuration is changed.
   void ScreenConfigurationChanged();
 
   // Synchronize the current buffer with |last_buffer_|, by copying pixels from
   // the area of |last_invalid_rects|.
   // Note this only works on the assumption that kNumBuffers == 2, as
   // |last_invalid_rects| holds the differences from the previous buffer and
   // the one prior to that (which will then be the current buffer).
   void SynchronizeFrame();
 
   void DeinitXlib();
 
   // Capture a rectangle from |x_server_pixel_buffer_|, and copy the data into
   // |capture_data|.
   void CaptureRect(const SkIRect& rect, CaptureData* capture_data);
 
   // We expose two forms of blitting to handle variations in the pixel format.
   // In FastBlit, the operation is effectively a memcpy.
   void FastBlit(uint8* image, const SkIRect& rect, CaptureData* capture_data);
   void SlowBlit(uint8* image, const SkIRect& rect, CaptureData* capture_data);
 
+  Delegate* delegate_;
+
   // X11 graphics context.
   Display* display_;
   GC gc_;
   Window root_window_;
 
   // XFixes.
   bool has_xfixes_;
   int xfixes_event_base_;
   int xfixes_error_base_;
 
   // XDamage information.
   bool use_damage_;
   Damage damage_handle_;
   int damage_event_base_;
   int damage_error_base_;
   XserverRegion damage_region_;
 
   // Access to the X Server's pixel buffer.
   XServerPixelBuffer x_server_pixel_buffer_;
 
   // 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_;
-
   // Capture state.
   static const int kNumBuffers = 2;
   VideoFrameBuffer buffers_[kNumBuffers];
   int current_buffer_;
 
   // Format of pixels returned in buffer.
   media::VideoFrame::Format pixel_format_;
 
   // Invalid region from the previous capture. This is used to synchronize the
   // current with the last buffer used.
   SkRegion last_invalid_region_;
 
   // Last capture buffer used.
   int last_buffer_;
 
   // |Differ| for use when polling for changes.
   scoped_ptr<Differ> differ_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerLinux);
 };
 
 VideoFrameCapturerLinux::VideoFrameCapturerLinux()
-    : display_(NULL),
+    : delegate_(NULL),
+      display_(NULL),
       gc_(NULL),
       root_window_(BadValue),
       has_xfixes_(false),
       xfixes_event_base_(-1),
       xfixes_error_base_(-1),
       use_damage_(false),
       damage_handle_(0),
       damage_event_base_(-1),
       damage_error_base_(-1),
       damage_region_(0),
@@ skipping 88 matching lines @@
   if (!damage_region_) {
     XDamageDestroy(display_, damage_handle_);
     LOG(ERROR) << "Unable to create XFixes region.";
     return;
   }
 
   use_damage_ = true;
   LOG(INFO) << "Using XDamage extension.";
 }
 
-void VideoFrameCapturerLinux::Start(
-    const CursorShapeChangedCallback& callback) {
-  cursor_shape_changed_callback_ = callback;
+void VideoFrameCapturerLinux::Start(Delegate* delegate) {
+  DCHECK(delegate_ == NULL);
+
+  delegate_ = delegate;
 }
 
 void VideoFrameCapturerLinux::Stop() {
 }
 
 media::VideoFrame::Format VideoFrameCapturerLinux::pixel_format() const {
   return pixel_format_;
 }
 
 void VideoFrameCapturerLinux::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void VideoFrameCapturerLinux::CaptureInvalidRegion(
-    const CaptureCompletedCallback& callback) {
+void VideoFrameCapturerLinux::CaptureInvalidRegion() {
   // Process XEvents for XDamage and cursor shape tracking.
   ProcessPendingXEvents();
 
   // Resize the current buffer if there was a recent change of
   // screen-resolution.
   VideoFrameBuffer &current = buffers_[current_buffer_];
   current.Update(display_, root_window_);
 
   // Mark the previous frame for update if its dimensions no longer match.
   if (buffers_[last_buffer_].size() != current.size()) {
     buffers_[last_buffer_].set_needs_update();
 
     // Also refresh the Differ helper used by CaptureFrame(), if needed.
     if (!use_damage_) {
       differ_.reset(new Differ(current.size().width(), current.size().height(),
                                kBytesPerPixel, current.bytes_per_row()));
     }
   }
 
   scoped_refptr<CaptureData> capture_data(CaptureFrame());
 
   // Swap the current & previous buffers ready for the next capture.
   last_invalid_region_ = capture_data->dirty_region();
   last_buffer_ = current_buffer_;
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
 
-  callback.Run(capture_data);
+  delegate_->OnCaptureCompleted(capture_data);
 }
 
 void VideoFrameCapturerLinux::ProcessPendingXEvents() {
   // Find the number of events that are outstanding "now."  We don't just loop
   // on XPending because we want to guarantee this terminates.
   int events_to_process = XPending(display_);
   XEvent e;
 
   for (int i = 0; i < events_to_process; i++) {
     XNextEvent(display_, &e);
@@ skipping 10 matching lines @@
         CaptureCursor();
       }
     } else {
       LOG(WARNING) << "Got unknown event type: " << e.type;
     }
   }
 }
 
 void VideoFrameCapturerLinux::CaptureCursor() {
   DCHECK(has_xfixes_);
-  if (cursor_shape_changed_callback_.is_null())
-    return;
 
   XFixesCursorImage* img = XFixesGetCursorImage(display_);
   if (!img) {
     return;
   }
 
   int width = img->width;
   int height = img->height;
   int total_bytes = width * height * kBytesPerPixel;
 
@@ skipping 10 matching lines @@
 
   // Xlib stores 32-bit data in longs, even if longs are 64-bits long.
   unsigned long* src = img->pixels;
   uint32* dst = reinterpret_cast<uint32*>(proto_data);
   uint32* dst_end = dst + (width * height);
   while (dst < dst_end) {
     *dst++ = static_cast<uint32>(*src++);
   }
   XFree(img);
 
-  cursor_shape_changed_callback_.Run(cursor_proto.Pass());
+  delegate_->OnCursorShapeChanged(cursor_proto.Pass());
 }
 
 CaptureData* VideoFrameCapturerLinux::CaptureFrame() {
   VideoFrameBuffer& buffer = buffers_[current_buffer_];
   DataPlanes planes;
   planes.data[0] = buffer.ptr();
   planes.strides[0] = buffer.bytes_per_row();
 
   CaptureData* capture_data = new CaptureData(planes, buffer.size(),
                                               media::VideoFrame::RGB32);
@@ skipping 214 matching lines @@
   }
   return capturer;
 }
 
 // static
 void VideoFrameCapturer::EnableXDamage(bool enable) {
   g_should_use_x_damage = enable;
 }
 
 }  // namespace remoting