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 <algorithm>
 
@@ skipping 134 matching lines @@
     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:
+      // TODO(jamescook): Need cursors for these.  crbug.com/111650
+      return XC_left_ptr;
     case aura::kCursorCustom:
-      // TODO(jamescook): Need cursors for these.  crbug.com/111650
+      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);
@@ skipping 99 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),
+      custom_cursor_(0),
       cursor_shown_(true),
       bounds_(bounds) {
   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(),
       0,               // border width
       CopyFromParent,  // depth
@@ skipping 257 matching lines @@
   current_cursor_ = cursor;
 
   // Custom web cursors are handled directly.
   if (cursor == kCursorCustom)
     return;
 
   if (cursor_shown_)
     SetCursorInternal(cursor);
 }
 
+void RootWindowHostLinux::SetCustomCursor(const gfx::PlatformCursor& cursor) {
+  if (custom_cursor_)
+    ui::UnrefCustomXCursor(custom_cursor_);

[Daniel Erat, 2012/02/24 21:04:36]

put this in the d'tor too

[sadrul, 2012/02/24 22:48:49]

Ah, good catch. Done.

+  custom_cursor_ = cursor;
+  if (custom_cursor_)
+    ui::RefCustomXCursor(custom_cursor_);
+  if (cursor_shown_)
+    XDefineCursor(xdisplay_, xwindow_, cursor);

[Daniel Erat, 2012/02/24 21:04:36]

i think that you need to make ShowCursor() handle the custom-cursor case too. 
what about something like the following?

- make SetCustomCursor() set custom_cursor_ to the passed-in cursor, set
current_cursor_ to kCursorCustom, and (if cursor_shown_ is true) call
SetCursorInternal(kCursorCustom)
- make SetCursorInternal() use custom_cursor_ (after CHECK()-ing that it's not
0) for the kCursorCustom case
- get rid of the cursor-unref-ing in SetCursorInternal(), and only unref in the
d'tor, SetCustomCursor(), and SetCursor()

[sadrul, 2012/02/24 22:48:49]

Very nice. Done!

One exception: I am not CHECK()ing in SetCursor for cursor != kCursorCustom.
This is because RootWindowEventFilter essentially does
root->SetCursor(target->GetCursor()). Doing this correctly in RWEF will involve
adding a corresponding GetCustomCursor on aura::Window, WindowDelegate, and
ref/unref-ing the custom cursor in RWEF (for a
|custom_cursor_to_set_on_unlock_|). I feel like that's bordering on too much
complication, and so decided against it.

[Daniel Erat, 2012/02/24 23:19:31]

Hmm, I see.  Will the current unsetting/unref-ing of custom_cursor_ in
SetCursor() cause problems here, since the custom cursor will be gone when we
try to restore it later?  Perhaps the old custom cursor should only be thrown
away in SetCustomCursor().

[sadrul, 2012/02/25 00:02:30]

I have changed the code in SetCursor to unset custom_cursor_ only if it wasn't
called with kCursorCustom.

[Daniel Erat, 2012/02/25 00:38:56]

So just to make sure that I understand correctly, is it now safe for
SetCursor(kCursorCustom) to be called even if custom_cursor_ is 0?  Or can this
never happen?  It seems like it can, if RootWindowEventFilter::UpdateCursor()
tries to set a custom cursor while the cursor is locked, but maybe this is
avoided for some other reason (I'm not familiar with RWEF).

+}
+
 void RootWindowHostLinux::ShowCursor(bool show) {
   if (show == cursor_shown_)
     return;
   cursor_shown_ = show;
   SetCursorInternal(show ? current_cursor_ : kCursorNone);
 }
 
 gfx::Point RootWindowHostLinux::QueryMouseLocation() {
   ::Window root_return, child_return;
   int root_x_return, root_y_return, win_x_return, win_y_return;
@@ skipping 77 matching lines @@
   ::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 ?
       invisible_cursor_ :
       ui::GetXCursor(CursorShapeFromNative(cursor));
   XDefineCursor(xdisplay_, xwindow_, xcursor);
+  if (custom_cursor_) {
+    ui::UnrefCustomXCursor(custom_cursor_);
+    custom_cursor_ = 0;
+  }
 }
 
 // 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