[Chromoting] Initial plumbing for cursor shape.

remoting/host/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/capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
+#include <X11/extensions/Xfixes.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "remoting/host/capturer_helper.h"
 #include "remoting/host/differ.h"
 #include "remoting/host/x_server_pixel_buffer.h"
 
@@ skipping 50 matching lines @@
 class CapturerLinux : public Capturer {
  public:
   CapturerLinux();
   virtual ~CapturerLinux();
 
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   // Capturer interface.
   virtual void Start() OVERRIDE;
   virtual void Stop() OVERRIDE;
+  virtual void SetCursorShapeChangedCallback(
+      const CursorShapeChangedCallback& callback) OVERRIDE;
   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(
       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.
   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 CapturerHelper 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 shape pixels and call the CursorShapeChangedCallback,

[Wez, 2012/05/16 00:20:04]

nit: "shape pixels" -> "image" ?

[garykac, 2012/05/22 00:42:03]

Done.

+  // if it has been set (using SetCursorShapeChangedCallback).
+  void CaptureCursor();
+
   // 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);
 
   // 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.
   CapturerHelper helper_;
 
+  // Callback to call whenever the cursor shape is changed.

[Wez, 2012/05/16 00:20:04]

nit: "Callback notified ..."

[garykac, 2012/05/22 00:42:03]

Done.

+  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.
   uint8* last_buffer_;
 
   // |Differ| for use when polling for changes.
   scoped_ptr<Differ> differ_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturerLinux);
 };
 
 CapturerLinux::CapturerLinux()
     : 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),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32),
       last_buffer_(NULL) {
   helper_.SetLogGridSize(4);
 }
@@ skipping 20 matching lines @@
     return false;
   }
 
   gc_ = XCreateGC(display_, root_window_, 0, NULL);
   if (gc_ == NULL) {
     LOG(ERROR) << "Unable to get graphics context";
     DeinitXlib();
     return false;
   }
 
+  // Check for XFixes extension. This is required for our XDamage support and

[Wez, 2012/05/16 00:20:04]

nit: Suggest "This is required for cursor shape notifications, and for our use
of XDamage."

[garykac, 2012/05/22 00:42:03]

Done.

+  // to get the cursor shape notifications.
+  if (XFixesQueryExtension(display_, &xfixes_event_base_,
+                           &xfixes_error_base_)) {
+    has_xfixes_ = true;
+  } else {
+    LOG(INFO) << "X server does not support XFixes.";
+  }
+
   if (ShouldUseXDamage()) {
     InitXDamage();
   }
 
   // Register for changes to the dimensions of the root window.
   XSelectInput(display_, root_window_, StructureNotifyMask);
 
+  if (has_xfixes_) {
+    // Register for changes to the cursor shape.
+    XFixesSelectCursorInput(display_, root_window_,
+                            XFixesDisplayCursorNotifyMask);
+  }
+
   return true;
 }
 
 void CapturerLinux::InitXDamage() {
-  // Check for XFixes and XDamage extensions.  If both are found then use
+  if (!has_xfixes_)
+    return;
+
+  // Check for XDamage extension. If this and XFixes are both found then use

[Wez, 2012/05/16 00:20:04]

nit: You've already tested for XFixes, so don't mention it in this comment? Or
add a comment to the |has_xfixes| test above.

[garykac, 2012/05/22 00:42:03]

Done.

   // XDamage to get explicit notifications of on-screen changes.
-  int xfixes_event_base;
-  int xfixes_error_base;
-  if (!XFixesQueryExtension(display_, &xfixes_event_base, &xfixes_error_base)) {
-    LOG(INFO) << "X server does not support XFixes.";
-    return;
-  }
   if (!XDamageQueryExtension(display_, &damage_event_base_,
                              &damage_error_base_)) {
     LOG(INFO) << "X server does not support XDamage.";
     return;
   }
 
   // TODO(lambroslambrou): Disable DAMAGE in situations where it is known
   // to fail, such as when Desktop Effects are enabled, with graphics
   // drivers (nVidia, ATI) that fail to report DAMAGE notifications
   // properly.
@@ skipping 17 matching lines @@
   use_damage_ = true;
   LOG(INFO) << "Using XDamage extension.";
 }
 
 void CapturerLinux::Start() {
 }
 
 void CapturerLinux::Stop() {
 }
 
+void CapturerLinux::SetCursorShapeChangedCallback(
+    const CursorShapeChangedCallback& callback) {
+  cursor_shape_changed_callback_ = callback;
+}
+
 void CapturerLinux::ScreenConfigurationChanged() {
   last_buffer_ = NULL;
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
   helper_.ClearInvalidRegion();
   x_server_pixel_buffer_.Init(display_);
 }
 
 media::VideoFrame::Format CapturerLinux::pixel_format() const {
@@ skipping 12 matching lines @@
   helper_.InvalidateScreen(size);
 }
 
 void CapturerLinux::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
   last_buffer_ = NULL;
 }
 
 void CapturerLinux::CaptureInvalidRegion(
     const CaptureCompletedCallback& callback) {
-  // TODO(lambroslambrou): In the non-DAMAGE case, there should be no need
-  // for any X event processing in this class.
+  // Process XEvents for XDamage and cursor shape.

[Wez, 2012/05/16 00:20:04]

nit: "... cursor shape tracking"

[garykac, 2012/05/22 00:42:03]

Done.

   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;
 
   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;
 
   for (int i = 0; i < events_to_process; i++) {
     XNextEvent(display_, &e);
     if (use_damage_ && (e.type == damage_event_base_ + XDamageNotify)) {
-      XDamageNotifyEvent *event = reinterpret_cast<XDamageNotifyEvent*>(&e);
+      XDamageNotifyEvent* event = reinterpret_cast<XDamageNotifyEvent*>(&e);
       DCHECK(event->level == XDamageReportNonEmpty);
     } else if (e.type == ConfigureNotify) {
       ScreenConfigurationChanged();
+    } else if (has_xfixes_ &&
+               e.type == xfixes_event_base_ + XFixesCursorNotify) {
+      XFixesCursorNotifyEvent* cne;
+      cne = reinterpret_cast<XFixesCursorNotifyEvent*>(&e);
+      if (cne->subtype == XFixesDisplayCursorNotify) {
+        CaptureCursor();
+      }
     } else {
       LOG(WARNING) << "Got unknown event type: " << e.type;
     }
   }
 }
 
+void CapturerLinux::CaptureCursor() {
+  DCHECK(has_xfixes_);
+  if (cursor_shape_changed_callback_.is_null())
+    return;
+
+  // TODO(garykac) Get cursor shape using XFixesGetCursorImage.
+
+  scoped_refptr<CursorShapeData> cursor_data;
+  cursor_shape_changed_callback_.Run(cursor_data);
+}
+
 CaptureData* CapturerLinux::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);
 
   // Pass the screen size to the helper, so it can clip the invalid region if it
@@ skipping 202 matching lines @@
   }
   return capturer;
 }
 
 // static
 void Capturer::EnableXDamage(bool enable) {
   g_should_use_x_damage = enable;
 }
 
 }  // namespace remoting