[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/base/capture_data.h"
 #include "remoting/host/capturer_helper.h"
 #include "remoting/host/differ.h"
 #include "remoting/host/x_server_pixel_buffer.h"
+#include "remoting/proto/control.pb.h"
 
 namespace remoting {
 
 namespace {
 
 static const int kBytesPerPixel = 4;
 
 // Default to false, since many systems have broken XDamage support - see
 // http://crbug.com/73423.
 static bool g_should_use_x_damage = false;
@@ skipping 39 matching lines @@
 
 // A class to perform capturing for Linux.
 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 Start(const CursorShapeChangedCallback& callback) OVERRIDE;
   virtual void Stop() 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;
@@ skipping 10 matching lines @@
 
   // 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 image and call the CursorShapeChangedCallback 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 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.
   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 cursor shape
+  // notifications, and for our use of XDamage.
+  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
-  // 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.";
+  // Our use of XDamage requires XFixes.
+  if (!has_xfixes_) {
     return;
   }
+
+  // Check for XDamage extension.
   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 11 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 CapturerLinux::Start() {
+void CapturerLinux::Start(
+    const CursorShapeChangedCallback& callback) {
+  cursor_shape_changed_callback_ = callback;
 }
 
 void CapturerLinux::Stop() {
 }
 
 void CapturerLinux::ScreenConfigurationChanged() {
   last_buffer_ = NULL;
   for (int i = 0; i < kNumBuffers; ++i) {
     buffers_[i].set_needs_update();
   }
@@ skipping 17 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 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_);
   // 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;
+
+  XFixesCursorImage* img = XFixesGetCursorImage(display_);
+  if (!img) {
+    return;
+  }
+
+  int width = img->width;
+  int height = img->height;
+  int total_bytes = width * height * kBytesPerPixel;
+
+  scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
+      new protocol::CursorShapeInfo());
+  cursor_proto->set_width(width);
+  cursor_proto->set_height(height);
+  cursor_proto->set_hotspot_x(img->xhot);
+  cursor_proto->set_hotspot_y(img->yhot);
+
+  cursor_proto->mutable_data()->resize(total_bytes);
+  uint8* proto_data = const_cast<uint8*>(reinterpret_cast<const uint8*>(
+      cursor_proto->mutable_data()->data()));
+
+  // 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());
+}
+
 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