[Chromoting] Initial plumbing for cursor shape.

remoting/host/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_CAPTURER_H_
 #define REMOTING_HOST_CAPTURER_H_
 
 #include "base/basictypes.h"
 #include "base/callback.h"
-#include "remoting/base/capture_data.h"
+#include "media/base/video_frame.h"
 #include "third_party/skia/include/core/SkRegion.h"
 
 namespace remoting {
 
+class CaptureData;
+class CursorShapeData;
+
 // A class to perform the task of capturing the image of a window.
 // The capture action is asynchronous to allow maximum throughput.
 //
 // The full capture process is as follows:
 //
 // (1) Start
 //     This is when pre-capture steps are executed, such as flagging the
 //     display to prevent it from sleeping during a session.
 //
 // (2) InvalidateRects
@@ skipping 17 matching lines @@
 //
 // Implementation has to ensure the following guarantees:
 // 1. Double buffering
 //    Since data can be read while another capture action is happening.
 class Capturer {
  public:
   // CaptureCompletedCallback is called when the capturer has completed.
   typedef base::Callback<void(scoped_refptr<CaptureData>)>
       CaptureCompletedCallback;
 
+  // CursorShapeChangedCallback is called when the cursor shape has changed.
+  typedef base::Callback<void(scoped_refptr<CursorShapeData>)>
+      CursorShapeChangedCallback;

[Wez, 2012/05/23 00:01:57]

If you have Capturers generate protocol::CursorShapeInfo directly then you can
get rid of this callback & the associated setter, and just pass a
CursorShapeCallback directly in to Start(); ScreenRecorder would either
implement that itself, or simply pass the HostControlDispatcher's
implementation.

[garykac, 2012/05/26 01:58:01]

Changed to protocol::CursorShapeInfo and removed setter. Still need callback to
pass into Start().

+
   virtual ~Capturer() {};
 
   // Create platform-specific capturer.
   static Capturer* Create();
 
 #if defined(OS_LINUX)
   // Set whether the Capturer should try to use X DAMAGE support if it is
   // available.  This needs to be called before the Capturer 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
   // Capturer::Create().  This is a temporary solution, until the
   // DesktopEnvironment class is refactored to allow applications to control
   // the creation of various stubs (including the Capturer) - 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() = 0;
 
   // Called at the end of a capturing session.
   virtual void Stop() = 0;
 
+  // Set callback to be called when the cursor shape changes.
+  virtual void SetCursorShapeChangedCallback(
+      const CursorShapeChangedCallback& callback) = 0;
+
   // Called when the screen configuration is changed.
   virtual void ScreenConfigurationChanged() = 0;
 
   // Return the pixel format of the screen.
   virtual media::VideoFrame::Format pixel_format() const = 0;
 
   // Clear out the invalid region.
   virtual void ClearInvalidRegion() = 0;
 
   // Invalidate the specified region.
@@ skipping 18 matching lines @@
   virtual void CaptureInvalidRegion(
       const CaptureCompletedCallback& callback) = 0;
 
   // Get the size of the most recently captured screen.
   virtual const SkISize& size_most_recent() const = 0;
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_CAPTURER_H_