aura-x11: Add custom web cursor support.

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 13 matching lines @@
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/x/x11_util_internal.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 #if defined(OS_FREEBSD)
+#include <sys/sysctl.h>
 #include <sys/types.h>
-#include <sys/sysctl.h>
+#endif
+
+#if defined(USE_AURA)
+#include <X11/Xcursor/Xcursor.h>
 #endif
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
+#include "ui/base/gtk/gdk_x_compat.h"
 #include "ui/base/gtk/gtk_compat.h"
-#include "ui/base/gtk/gdk_x_compat.h"
 #else
 // TODO(sad): Use the new way of handling X errors when
 // http://codereview.chromium.org/7889040/ lands.
 #define gdk_error_trap_push()
 #define gdk_error_trap_pop() false
 #define gdk_flush()
 #endif
 
 namespace ui {
 
@@ skipping 99 matching lines @@
 }
 
 // A process wide singleton that manages the usage of X cursors.
 class XCursorCache {
  public:
    XCursorCache() {}
   ~XCursorCache() {
     Clear();
   }
 
-  Cursor GetCursor(int cursor_shape) {
+  ::Cursor GetCursor(int cursor_shape) {
     // Lookup cursor by attempting to insert a null value, which avoids
     // a second pass through the map after a cache miss.
-    std::pair<std::map<int, Cursor>::iterator, bool> it = cache_.insert(
+    std::pair<std::map<int, ::Cursor>::iterator, bool> it = cache_.insert(
         std::make_pair(cursor_shape, 0));
     if (it.second) {
       Display* display = base::MessagePumpForUI::GetDefaultXDisplay();
       it.first->second = XCreateFontCursor(display, cursor_shape);
     }
     return it.first->second;
   }
 
   void Clear() {
     Display* display = base::MessagePumpForUI::GetDefaultXDisplay();
-    for (std::map<int, Cursor>::iterator it =
+    for (std::map<int, ::Cursor>::iterator it =
         cache_.begin(); it != cache_.end(); ++it) {
       XFreeCursor(display, it->second);
     }
     cache_.clear();
   }
 
  private:
   // Maps X11 font cursor shapes to Cursor IDs.
-  std::map<int, Cursor> cache_;
+  std::map<int, ::Cursor> cache_;
 
   DISALLOW_COPY_AND_ASSIGN(XCursorCache);
 };
 
+#if defined(USE_AURA)
+// A process wide singleton cache for custom X cursors.
+class XCustomCursorCache {
+ public:
+  static XCustomCursorCache* GetInstance() {
+    return Singleton<XCustomCursorCache>::get();
+  }
+
+  ::Cursor InstallCustomCursor(XcursorImage* image) {
+    XCustomCursor* custom_cursor = new XCustomCursor(image);
+    ::Cursor xcursor = custom_cursor->cursor();
+    cache_[xcursor] = custom_cursor;
+    return xcursor;
+  }
+
+  void Ref(::Cursor cursor) {
+    cache_[cursor]->Ref();
+  }
+
+  void Unref(::Cursor cursor) {
+    if (cache_[cursor]->Unref())
+      cache_.erase(cursor);
+  }
+
+  void Clear() {
+    cache_.clear();
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<XCustomCursorCache>;
+
+  class XCustomCursor {
+   public:
+    // This takes ownership of the image.
+    XCustomCursor(XcursorImage* image)
+        : image_(image),
+          ref_(1) {
+      cursor_ = XcursorImageLoadCursor(GetXDisplay(), image);
+    }
+
+    ~XCustomCursor() {
+      XcursorImageDestroy(image_);
+      XFreeCursor(GetXDisplay(), cursor_);
+    }
+
+    ::Cursor cursor() const { return cursor_; }
+
+    void Ref() {
+      ++ref_;
+    }
+
+    // Returns true if the cursor was destroyed because of the unref.
+    bool Unref() {
+      if (--ref_ == 0) {
+        delete this;
+        return true;
+      }
+      return false;
+    }
+
+   private:
+    XcursorImage* image_;
+    int ref_;
+    ::Cursor cursor_;
+
+    DISALLOW_COPY_AND_ASSIGN(XCustomCursor);
+  };
+
+  XCustomCursorCache() {}
+  ~XCustomCursorCache() {
+    Clear();
+  }
+
+  std::map< ::Cursor, XCustomCursor*> cache_;
+  DISALLOW_COPY_AND_ASSIGN(XCustomCursorCache);
+};
+#endif  // defined(USE_AURA)
+
 // A singleton object that remembers remappings of mouse buttons.
 class XButtonMap {
  public:
   static XButtonMap* GetInstance() {
     return Singleton<XButtonMap>::get();
   }
 
   void UpdateMapping() {
     count_ = XGetPointerMapping(ui::GetXDisplay(), map_, arraysize(map_));
   }
@@ skipping 98 matching lines @@
   render_supported = XRenderQueryExtension(dpy, &dummy, &dummy);
   render_supported_cached = true;
 
   return render_supported;
 }
 
 int GetDefaultScreen(Display* display) {
   return XDefaultScreen(display);
 }
 
-Cursor GetXCursor(int cursor_shape) {
+::Cursor GetXCursor(int cursor_shape) {
   CR_DEFINE_STATIC_LOCAL(XCursorCache, cache, ());
 
   if (cursor_shape == kCursorClearXCursorCache) {
     cache.Clear();
     return 0;
   }
 
   return cache.GetCursor(cursor_shape);
 }
 
+#if defined(USE_AURA)
+::Cursor CreateReffedCustomXCursor(XcursorImage* image) {
+  return XCustomCursorCache::GetInstance()->InstallCustomCursor(image);
+}
+
+void RefCustomXCursor(::Cursor cursor) {
+  XCustomCursorCache::GetInstance()->Ref(cursor);
+}
+
+void UnrefCustomXCursor(::Cursor cursor) {
+  XCustomCursorCache::GetInstance()->Unref(cursor);
+}
+#endif
+
 XID GetX11RootWindow() {
   return DefaultRootWindow(GetXDisplay());
 }
 
 bool GetCurrentDesktop(int* desktop) {
   return GetIntProperty(GetX11RootWindow(), "_NET_CURRENT_DESKTOP", desktop);
 }
 
 #if defined(TOOLKIT_USES_GTK)
 XID GetX11WindowFromGtkWidget(GtkWidget* widget) {
@@ skipping 800 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui