Move code in src/remoting to the new callbacks.

remoting/host/capturer_linux.cc

 // Copyright (c) 2011 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/capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 
@@ skipping 61 matching lines @@
 
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   // Capturer interface.
   virtual void ScreenConfigurationChanged() OVERRIDE;
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
   virtual void ClearInvalidRegion() OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE;
   virtual void InvalidateScreen(const SkISize& size) OVERRIDE;
   virtual void InvalidateFullScreen() OVERRIDE;
-  virtual void CaptureInvalidRegion(CaptureCompletedCallback* callback)
-      OVERRIDE;
+  virtual void CaptureInvalidRegion(
+      const CaptureCompletedCallback& callback) 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 CapturerHelper.
   // In all cases, call ScreenConfigurationChanged() in response to any
   // ConfigNotify events.
@@ skipping 163 matching lines @@
 void CapturerLinux::InvalidateScreen(const SkISize& size) {
   helper_.InvalidateScreen(size);
 }
 
 void CapturerLinux::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
   last_buffer_ = NULL;
 }
 
 void CapturerLinux::CaptureInvalidRegion(
-    CaptureCompletedCallback* callback) {
-  scoped_ptr<CaptureCompletedCallback> callback_deleter(callback);
-
+    const CaptureCompletedCallback& callback) {
   // TODO(lambroslambrou): In the non-DAMAGE case, there should be no need
   // for any X event processing in this class.
   ProcessPendingXEvents();
 
   // Resize the current buffer if there was a recent change of
   // screen-resolution.
   VideoFrameBuffer &current = buffers_[current_buffer_];
   current.Update(display_, root_window_);
   // Also refresh the Differ helper used by CaptureFrame(), if needed.
   if (!use_damage_ && !last_buffer_) {
     differ_.reset(new Differ(current.size().width(), current.size().height(),
                              kBytesPerPixel, current.bytes_per_row()));
   }
 
   scoped_refptr<CaptureData> capture_data(CaptureFrame());
 
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
   helper_.set_size_most_recent(capture_data->size());
 
-  callback->Run(capture_data);
+  callback.Run(capture_data);
 }
 
 void CapturerLinux::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;
   SkRegion invalid_region;
 
   for (int i = 0; i < events_to_process; i++) {
@@ skipping 209 matching lines @@
 Capturer* Capturer::Create() {
   CapturerLinux* capturer = new CapturerLinux();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting