aura-x11: Add custom web cursor support.

ui/aura/root_window_host_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 "ui/aura/root_window_host_linux.h"
 
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/Xrandr.h>
 #include <algorithm>
 
 #include "base/message_pump_x.h"
 #include "base/stl_util.h"
 #include "base/stringprintf.h"
-#include "ui/aura/cursor.h"
 #include "ui/aura/dispatcher_linux.h"
 #include "ui/aura/env.h"
 #include "ui/aura/event.h"
 #include "ui/aura/monitor.h"
 #include "ui/aura/monitor_manager.h"
 #include "ui/aura/root_window.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/touch/touch_factory.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/compositor/layer.h"
 
 using std::max;
 using std::min;
 
 namespace aura {
 
@@ skipping 43 matching lines @@
     CHECK_EQ(slave_event.valuators.mask_len, xievent->valuators.mask_len);
     CHECK_EQ(slave_event.mods.base, xievent->mods.base);
     CHECK_EQ(slave_event.mods.latched, xievent->mods.latched);
     CHECK_EQ(slave_event.mods.locked, xievent->mods.locked);
     CHECK_EQ(slave_event.mods.effective, xievent->mods.effective);
   }
 }
 
 // Returns X font cursor shape from an Aura cursor.
 int CursorShapeFromNative(gfx::NativeCursor native_cursor) {
-  switch (native_cursor) {
-    case aura::kCursorNull:
+  switch (native_cursor.native_type()) {
+    case ui::kCursorNull:
       return XC_left_ptr;
-    case aura::kCursorPointer:
+    case ui::kCursorPointer:
       return XC_left_ptr;
-    case aura::kCursorCross:
+    case ui::kCursorCross:
       return XC_crosshair;
-    case aura::kCursorHand:
+    case ui::kCursorHand:
       return XC_hand2;
-    case aura::kCursorIBeam:
+    case ui::kCursorIBeam:
       return XC_xterm;
-    case aura::kCursorWait:
+    case ui::kCursorWait:
       return XC_watch;
-    case aura::kCursorHelp:
+    case ui::kCursorHelp:
       return XC_question_arrow;
-    case aura::kCursorEastResize:
+    case ui::kCursorEastResize:
       return XC_right_side;
-    case aura::kCursorNorthResize:
+    case ui::kCursorNorthResize:
       return XC_top_side;
-    case aura::kCursorNorthEastResize:
+    case ui::kCursorNorthEastResize:
       return XC_top_right_corner;
-    case aura::kCursorNorthWestResize:
+    case ui::kCursorNorthWestResize:
       return XC_top_left_corner;
-    case aura::kCursorSouthResize:
+    case ui::kCursorSouthResize:
       return XC_bottom_side;
-    case aura::kCursorSouthEastResize:
+    case ui::kCursorSouthEastResize:
       return XC_bottom_right_corner;
-    case aura::kCursorSouthWestResize:
+    case ui::kCursorSouthWestResize:
       return XC_bottom_left_corner;
-    case aura::kCursorWestResize:
+    case ui::kCursorWestResize:
       return XC_left_side;
-    case aura::kCursorNorthSouthResize:
+    case ui::kCursorNorthSouthResize:
       return XC_sb_v_double_arrow;
-    case aura::kCursorEastWestResize:
+    case ui::kCursorEastWestResize:
       return XC_sb_h_double_arrow;
-    case aura::kCursorNorthEastSouthWestResize:
-    case aura::kCursorNorthWestSouthEastResize:
+    case ui::kCursorNorthEastSouthWestResize:
+    case ui::kCursorNorthWestSouthEastResize:
       // There isn't really a useful cursor available for these.
       return XC_left_ptr;
-    case aura::kCursorColumnResize:
+    case ui::kCursorColumnResize:
       return XC_sb_h_double_arrow;
-    case aura::kCursorRowResize:
+    case ui::kCursorRowResize:
       return XC_sb_v_double_arrow;
-    case aura::kCursorMiddlePanning:
+    case ui::kCursorMiddlePanning:
       return XC_fleur;
-    case aura::kCursorEastPanning:
+    case ui::kCursorEastPanning:
       return XC_sb_right_arrow;
-    case aura::kCursorNorthPanning:
+    case ui::kCursorNorthPanning:
       return XC_sb_up_arrow;
-    case aura::kCursorNorthEastPanning:
+    case ui::kCursorNorthEastPanning:
       return XC_top_right_corner;
-    case aura::kCursorNorthWestPanning:
+    case ui::kCursorNorthWestPanning:
       return XC_top_left_corner;
-    case aura::kCursorSouthPanning:
+    case ui::kCursorSouthPanning:
       return XC_sb_down_arrow;
-    case aura::kCursorSouthEastPanning:
+    case ui::kCursorSouthEastPanning:
       return XC_bottom_right_corner;
-    case aura::kCursorSouthWestPanning:
+    case ui::kCursorSouthWestPanning:
       return XC_bottom_left_corner;
-    case aura::kCursorWestPanning:
+    case ui::kCursorWestPanning:
       return XC_sb_left_arrow;
-    case aura::kCursorMove:
+    case ui::kCursorMove:
       return XC_fleur;
-    case aura::kCursorVerticalText:
-    case aura::kCursorCell:
-    case aura::kCursorContextMenu:
-    case aura::kCursorAlias:
-    case aura::kCursorProgress:
-    case aura::kCursorNoDrop:
-    case aura::kCursorCopy:
-    case aura::kCursorNone:
-    case aura::kCursorNotAllowed:
-    case aura::kCursorZoomIn:
-    case aura::kCursorZoomOut:
-    case aura::kCursorGrab:
-    case aura::kCursorGrabbing:
-    case aura::kCursorCustom:
+    case ui::kCursorVerticalText:
+    case ui::kCursorCell:
+    case ui::kCursorContextMenu:
+    case ui::kCursorAlias:
+    case ui::kCursorProgress:
+    case ui::kCursorNoDrop:
+    case ui::kCursorCopy:
+    case ui::kCursorNone:
+    case ui::kCursorNotAllowed:
+    case ui::kCursorZoomIn:
+    case ui::kCursorZoomOut:
+    case ui::kCursorGrab:
+    case ui::kCursorGrabbing:
       // TODO(jamescook): Need cursors for these.  crbug.com/111650
       return XC_left_ptr;
+    case ui::kCursorCustom:
+      NOTREACHED();
+      return XC_left_ptr;
   }
   NOTREACHED();
   return XC_left_ptr;
 }
 
 // Coalesce all pending motion events that are at the top of the queue, and
 // return the number eliminated, storing the last one in |last_event|.
 int CoalescePendingXIMotionEvents(const XEvent* xev, XEvent* last_event) {
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
   int num_coalesed = 0;
@@ skipping 97 matching lines @@
   }
 }
 
 }  // namespace
 
 RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
     : root_window_(NULL),
       xdisplay_(base::MessagePumpX::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
-      current_cursor_(aura::kCursorNull),
+      current_cursor_(ui::kCursorNull),
       cursor_shown_(true),
       bounds_(bounds),
       focus_when_shown_(false),
       pointer_barriers_(NULL) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds_.x(), bounds_.y(), bounds_.width(), bounds_.height(),
@@ skipping 263 matching lines @@
 }
 
 void RootWindowHostLinux::ReleaseCapture() {
 }
 
 void RootWindowHostLinux::SetCursor(gfx::NativeCursor cursor) {
   if (cursor == current_cursor_)
     return;
   current_cursor_ = cursor;
 
-  // Custom web cursors are handled directly.
-  if (cursor == kCursorCustom)
-    return;
-
   if (cursor_shown_)
     SetCursorInternal(cursor);
 }
 
 void RootWindowHostLinux::ShowCursor(bool show) {
   if (show == cursor_shown_)
     return;
   cursor_shown_ = show;
-  SetCursorInternal(show ? current_cursor_ : kCursorNone);
+  SetCursorInternal(show ? current_cursor_ : ui::kCursorNone);
 }
 
 gfx::Point RootWindowHostLinux::QueryMouseLocation() {
   ::Window root_return, child_return;
   int root_x_return, root_y_return, win_x_return, win_y_return;
   unsigned int mask_return;
   XQueryPointer(xdisplay_,
                 xwindow_,
                 &root_return,
                 &child_return,
@@ skipping 102 matching lines @@
 
 bool RootWindowHostLinux::IsWindowManagerPresent() {
   // Per ICCCM 2.8, "Manager Selections", window managers should take ownership
   // of WM_Sn selections (where n is a screen number).
   ::Atom wm_s0_atom = XInternAtom(xdisplay_, "WM_S0", False);
   return XGetSelectionOwner(xdisplay_, wm_s0_atom) != None;
 }
 
 void RootWindowHostLinux::SetCursorInternal(gfx::NativeCursor cursor) {
   ::Cursor xcursor =
-      cursor == kCursorNone ?
+      cursor == ui::kCursorNone ?
       invisible_cursor_ :
+      cursor == ui::kCursorCustom ?
+      cursor.platform() :
       ui::GetXCursor(CursorShapeFromNative(cursor));
   XDefineCursor(xdisplay_, xwindow_, xcursor);
 }
 
 // static
 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
   return new RootWindowHostLinux(bounds);
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpX::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura