Converted VideoFrameCapturer callbacks into a VideoFrameCapturer::Delegate interface.

remoting/host/video_frame_capturer.h

 // 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.
 
 #ifndef REMOTING_HOST_VIDEO_FRAME_CAPTURER_H_
 #define REMOTING_HOST_VIDEO_FRAME_CAPTURER_H_
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "media/base/video_frame.h"
@@ skipping 32 matching lines @@
 //
 // (4) Stop
 //     This is when post-capture steps are executed, such as releasing the
 //     assertion that prevents the display from sleeping.
 //
 // Implementation has to ensure the following guarantees:
 // 1. Double buffering
 //    Since data can be read while another capture action is happening.
 class VideoFrameCapturer {
  public:
-  // CaptureCompletedCallback is called when the capturer has completed.
-  typedef base::Callback<void(scoped_refptr<CaptureData>)>
-      CaptureCompletedCallback;
+  // Provides callbacks used by the capturer to pass captured video frames and
+  // mouse cursor shapes to the processing pipeline.
+  class Delegate {
+   public:
+    virtual ~Delegate() {}
 
-  // CursorShapeChangedCallback is called when the cursor shape has changed.
-  typedef base::Callback<void(scoped_ptr<protocol::CursorShapeInfo>)>
-      CursorShapeChangedCallback;
+    // Called when the capturer has completed. |capture_data| describes
+    // a captured frame.
+    virtual void OnCaptureCompleted(
+        scoped_refptr<CaptureData> capture_data) = 0;
+
+    // Called when the cursor shape has changed.
+    virtual void OnCursorShapeChanged(
+        scoped_ptr<protocol::CursorShapeInfo> cursor_shape) = 0;
+  };
 
   virtual ~VideoFrameCapturer() {}
 
   // Create platform-specific capturer.
   static VideoFrameCapturer* Create();
 
 #if defined(OS_LINUX)
   // Set whether the VideoFrameCapturer should try to use X DAMAGE support if it
   // is available. This needs to be called before the VideoFrameCapturer is
   // created.
   // This is used by the Virtual Me2Me host, since the XDamage extension is
   // known to work reliably in this case.
 
   // TODO(lambroslambrou): This currently sets a global flag, referenced during
   // VideoFrameCapturer::Create().  This is a temporary solution, until the
   // DesktopEnvironment class is refactored to allow applications to control
   // the creation of various stubs (including the VideoFrameCapturer) - see
   // http://crbug.com/104544
   static void EnableXDamage(bool enable);
 #endif  // defined(OS_LINUX)
 
-  // Called at the beginning of a capturing session.
-  virtual void Start(
-      const CursorShapeChangedCallback& callback) = 0;
+  // Called at the beginning of a capturing session. |delegate| must remain
+  // valid until Stop() is called.
+  virtual void Start(Delegate* delegate) = 0;
 
   // Called at the end of a capturing session.
   virtual void Stop() = 0;
 
-  // Return the pixel format of the screen.
+  // Returns the pixel format of the screen.
   virtual media::VideoFrame::Format pixel_format() const = 0;
 
-  // Invalidate the specified region.
+  // Invalidates the specified region.
   virtual void InvalidateRegion(const SkRegion& invalid_region) = 0;
 
-  // Capture the screen data associated with each of the accumulated
-  // dirty region.
-  // When the capture is complete, |callback| is called even if the dirty region
-  // is empty.
+  // Captures the screen data associated with each of the accumulated
+  // dirty region. When the capture is complete, the delegate is notified even
+  // if the dirty region is empty.
   //
   // It is OK to call this method while another thread is reading
-  // data of the previous capture.
-  // There can be at most one concurrent read going on when this
-  // method is called.
-  virtual void CaptureInvalidRegion(
-      const CaptureCompletedCallback& callback) = 0;
+  // data of the previous capture. There can be at most one concurrent read
+  // going on when this method is called.
+  virtual void CaptureInvalidRegion() = 0;
 
   // Get the size of the most recently captured screen.
   virtual const SkISize& size_most_recent() const = 0;
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_VIDEO_FRAME_CAPTURER_H_