Linux Aura: Fixes and improvements for cursor loader

ui/base/cursor/cursor_loader_x11.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/base/cursor/cursor_loader_x11.h"
 
 #include <float.h>
 #include <X11/cursorfont.h>
 #include <X11/Xlib.h>
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/cursor_util.h"
+#include "ui/base/cursor/cursors_aura.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/display/display.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
 
-// Returns X font cursor shape from an Aura cursor.
-int CursorShapeFromNative(const gfx::NativeCursor& native_cursor) {
-  switch (native_cursor.native_type()) {
+// Returns CSS cursor name from an Aura cursor ID.
+const char* CursorCssNameFromId(int id) {
+  switch (id) {
     case ui::kCursorMiddlePanning:
-      return XC_fleur;
     case ui::kCursorEastPanning:
-      return XC_sb_right_arrow;
     case ui::kCursorNorthPanning:
-      return XC_sb_up_arrow;
     case ui::kCursorNorthEastPanning:
-      return XC_top_right_corner;
     case ui::kCursorNorthWestPanning:
-      return XC_top_left_corner;
     case ui::kCursorSouthPanning:
-      return XC_sb_down_arrow;
     case ui::kCursorSouthEastPanning:
-      return XC_bottom_right_corner;
     case ui::kCursorSouthWestPanning:
-      return XC_bottom_left_corner;
     case ui::kCursorWestPanning:
-      return XC_sb_left_arrow;
+      NOTREACHED() << "There's no middle-click panning on Linux or ChromeOS";
+      return "left_ptr";
     case ui::kCursorNone:
+      return "none";
     case ui::kCursorGrab:
+      return "grab";
     case ui::kCursorGrabbing:
-      // TODO(jamescook): Need cursors for these.  crbug.com/111650
-      return XC_left_ptr;
+      return "grabbing";
 
 #if defined(OS_CHROMEOS)
     case ui::kCursorNull:
     case ui::kCursorPointer:
     case ui::kCursorNoDrop:
     case ui::kCursorNotAllowed:
     case ui::kCursorCopy:
     case ui::kCursorMove:
     case ui::kCursorEastResize:
     case ui::kCursorNorthResize:
@@ skipping 16 matching lines @@
     case ui::kCursorNorthWestSouthEastResize:
     case ui::kCursorProgress:
     case ui::kCursorColumnResize:
     case ui::kCursorRowResize:
     case ui::kCursorVerticalText:
     case ui::kCursorZoomIn:
     case ui::kCursorZoomOut:
     case ui::kCursorHand:
       // In some environments, the image assets are not set (e.g. in
       // content-browsertests, content-shell etc.).
-      return XC_left_ptr;
+      return "left_ptr";
 #else  // defined(OS_CHROMEOS)
     case ui::kCursorNull:
-      return XC_left_ptr;
+      return "left_ptr";
     case ui::kCursorPointer:
-      return XC_left_ptr;
+      return "left_ptr";
     case ui::kCursorMove:
-      return XC_fleur;
+      return "move";
     case ui::kCursorCross:
-      return XC_crosshair;
+      return "crosshair";
     case ui::kCursorHand:
-      return XC_hand2;
+      return "pointer";
     case ui::kCursorIBeam:
-      return XC_xterm;
+      return "text";
     case ui::kCursorProgress:
+      return "progress";
     case ui::kCursorWait:
-      return XC_watch;
+      return "wait";
     case ui::kCursorHelp:
-      return XC_question_arrow;
+      return "help";
     case ui::kCursorEastResize:
-      return XC_right_side;
+      return "e-resize";
     case ui::kCursorNorthResize:
-      return XC_top_side;
+      return "n-resize";
     case ui::kCursorNorthEastResize:
-      return XC_top_right_corner;
+      return "ne-resize";
     case ui::kCursorNorthWestResize:
-      return XC_top_left_corner;
+      return "nw-resize";
     case ui::kCursorSouthResize:
-      return XC_bottom_side;
+      return "s-resize";
     case ui::kCursorSouthEastResize:
-      return XC_bottom_right_corner;
+      return "se-resize";
     case ui::kCursorSouthWestResize:
-      return XC_bottom_left_corner;
+      return "sw-resize";
     case ui::kCursorWestResize:
-      return XC_left_side;
+      return "w-resize";
     case ui::kCursorNorthSouthResize:
-      return XC_sb_v_double_arrow;
+      return "ns-resize";
     case ui::kCursorEastWestResize:
-      return XC_sb_h_double_arrow;
+      return "ew-resize";
     case ui::kCursorColumnResize:
-      return XC_sb_h_double_arrow;
+      return "col-resize";
     case ui::kCursorRowResize:
-      return XC_sb_v_double_arrow;
+      return "row-resize";
+    case ui::kCursorNorthEastSouthWestResize:
+      return "nesw-resize";
+    case ui::kCursorNorthWestSouthEastResize:
+      return "nwse-resize";
+    case ui::kCursorVerticalText:
+      return "vertical-text";
+    case ui::kCursorZoomIn:
+      return "zoom-in";
+    case ui::kCursorZoomOut:
+      return "zoom-out";
+    case ui::kCursorCell:
+      return "cell";
+    case ui::kCursorContextMenu:
+      return "context-menu";
+    case ui::kCursorAlias:
+      return "alias";
+    case ui::kCursorNoDrop:
+      return "no-drop";
+    case ui::kCursorCopy:
+      return "copy";
+    case ui::kCursorNotAllowed:
+      return "not-allowed";
+    case ui::kCursorDndNone:
+      return "dnd-none";
+    case ui::kCursorDndMove:
+      return "dnd-move";
+    case ui::kCursorDndCopy:
+      return "dnd-copy";
+    case ui::kCursorDndLink:
+      return "dnd-link";
 #endif  // defined(OS_CHROMEOS)
     case ui::kCursorCustom:
       NOTREACHED();
-      return XC_left_ptr;
+      return "left_ptr";
   }
-  NOTREACHED() << "Case not handled for " << native_cursor.native_type();
-  return XC_left_ptr;
+  NOTREACHED() << "Case not handled for " << id;
+  return "left_ptr";
 }
 
+static const struct {
+  const char* css_name;
+  const char* traditional_name;
+  int shape;
+} kCursorFallbacks[] = {
+    { "pointer",     "hand",            XC_hand1 },
+    { "progress",    "left_ptr_watch",  XC_watch },
+    { "wait",        nullptr,           XC_watch },
+    { "cell",        nullptr,           XC_plus },
+    { "crosshair",   nullptr,           XC_cross },
+    { "text",        nullptr,           XC_xterm },
+    { "not-allowed", "crossed_circle",  None },
+    { "grabbing",    nullptr,           XC_hand2 },
+    { "col-resize",  nullptr,           XC_sb_h_double_arrow },
+    { "row-resize",  nullptr,           XC_sb_v_double_arrow},
+    { "n-resize",    nullptr,           XC_top_side},
+    { "e-resize",    nullptr,           XC_right_side},
+    { "s-resize",    nullptr,           XC_bottom_side},
+    { "w-resize",    nullptr,           XC_left_side},
+    { "ne-resize",   nullptr,           XC_top_right_corner},
+    { "nw-resize",   nullptr,           XC_top_left_corner},
+    { "se-resize",   nullptr,           XC_bottom_right_corner},
+    { "sw-resize",   nullptr,           XC_bottom_left_corner},
+    { "ew-resize",   nullptr,           XC_sb_h_double_arrow},
+    { "ns-resize",   nullptr,           XC_sb_v_double_arrow},
+    { "nesw-resize", "fd_double_arrow", None},
+    { "nwse-resize", "bd_double_arrow", None},
+};
+
 }  // namespace
 
 namespace ui {
 
 CursorLoader* CursorLoader::Create() {
   return new CursorLoaderX11;
 }
 
+CursorLoaderX11::ImageCursor::ImageCursor(XcursorImage* x_image,
+                                       float scale,
+                                       display::Display::Rotation rotation)
+    : scale(scale), rotation(rotation) {
+  cursor = CreateReffedCustomXCursor(x_image);
+}
+
+CursorLoaderX11::ImageCursor::~ImageCursor() {
+  UnrefCustomXCursor(cursor);
+}
+
 CursorLoaderX11::CursorLoaderX11()
-    : invisible_cursor_(CreateInvisibleCursor(), gfx::GetXDisplay()) {
-}
+    : display_(gfx::GetXDisplay()),
+      invisible_cursor_(CreateInvisibleCursor(), gfx::GetXDisplay()) {}
 
 CursorLoaderX11::~CursorLoaderX11() {
   UnloadAll();
 }
 
 void CursorLoaderX11::LoadImageCursor(int id,
                                       int resource_id,
                                       const gfx::Point& hot) {
   SkBitmap bitmap;
   gfx::Point hotspot = hot;
 
   GetImageCursorBitmap(resource_id, scale(), rotation(), &hotspot, &bitmap);
   XcursorImage* x_image = SkBitmapToXcursorImage(&bitmap, hotspot);
-  cursors_[id] = CreateReffedCustomXCursor(x_image);
+  image_cursors_[id].reset(new ImageCursor(x_image, scale(), rotation()));
 }
 
 void CursorLoaderX11::LoadAnimatedCursor(int id,
                                          int resource_id,
                                          const gfx::Point& hot,
                                          int frame_delay_ms) {
   std::vector<SkBitmap> bitmaps;
   gfx::Point hotspot = hot;
 
-  GetAnimatedCursorBitmaps(
-      resource_id, scale(), rotation(), &hotspot, &bitmaps);
+  GetAnimatedCursorBitmaps(resource_id, scale(), rotation(), &hotspot,
+                           &bitmaps);
 
   XcursorImages* x_images = XcursorImagesCreate(bitmaps.size());
   x_images->nimage = bitmaps.size();
 
   for (unsigned int frame = 0; frame < bitmaps.size(); ++frame) {
     XcursorImage* x_image = SkBitmapToXcursorImage(&bitmaps[frame], hotspot);
     x_image->delay = frame_delay_ms;
     x_images->images[frame] = x_image;
   }
 
   animated_cursors_[id] = std::make_pair(
       XcursorImagesLoadCursor(gfx::GetXDisplay(), x_images), x_images);
 }
 
 void CursorLoaderX11::UnloadAll() {
-  for (ImageCursorMap::const_iterator it = cursors_.begin();
-       it != cursors_.end(); ++it)
-    UnrefCustomXCursor(it->second);
+  image_cursors_.clear();
 
   // Free animated cursors and images.
-  for (AnimatedCursorMap::iterator it = animated_cursors_.begin();
-       it != animated_cursors_.end(); ++it) {
-    XcursorImagesDestroy(it->second.second);  // also frees individual frames.
-    XFreeCursor(gfx::GetXDisplay(), it->second.first);
+  for (const auto& cursor : animated_cursors_) {
+    XcursorImagesDestroy(
+        cursor.second.second);  // also frees individual frames.
+    XFreeCursor(gfx::GetXDisplay(), cursor.second.first);
   }
 }
 
 void CursorLoaderX11::SetPlatformCursor(gfx::NativeCursor* cursor) {
   DCHECK(cursor);
 
-  ::Cursor xcursor;
-  if (IsImageCursor(*cursor))
-    xcursor = ImageCursorFromNative(*cursor);
-  else if (*cursor == kCursorNone)
-    xcursor =  invisible_cursor_.get();
-  else if (*cursor == kCursorCustom)
-    xcursor = cursor->platform();
-  else if (scale() == 1.0f && rotation() == display::Display::ROTATE_0) {
-    xcursor = GetXCursor(CursorShapeFromNative(*cursor));
-  } else {
-    xcursor = ImageCursorFromNative(kCursorPointer);
+  if (*cursor == kCursorNone) {
+    cursor->SetPlatformCursor(invisible_cursor_.get());
+    return;
   }
 
-  cursor->SetPlatformCursor(xcursor);
+  if (*cursor == kCursorCustom)
+    return;
+
+  cursor->SetPlatformCursor(CursorFromId(cursor->native_type()));
 }
 
 const XcursorImage* CursorLoaderX11::GetXcursorImageForTest(int id) {
-  return test::GetCachedXcursorImage(cursors_[id]);
+  return test::GetCachedXcursorImage(image_cursors_[id]->cursor);
 }
 
 bool CursorLoaderX11::IsImageCursor(gfx::NativeCursor native_cursor) {
   int type = native_cursor.native_type();
-  return cursors_.count(type) || animated_cursors_.count(type);
+  return image_cursors_.count(type) || animated_cursors_.count(type);
 }
 
-::Cursor CursorLoaderX11::ImageCursorFromNative(
-    gfx::NativeCursor native_cursor) {
-  int type = native_cursor.native_type();
-  if (animated_cursors_.count(type))
-    return animated_cursors_[type].first;
+::Cursor CursorLoaderX11::CursorFromId(int id) {
+  const char* css_name = CursorCssNameFromId(id);
 
-  ImageCursorMap::iterator find = cursors_.find(type);
-  if (find != cursors_.end())
-    return cursors_[type];
-  return GetXCursor(CursorShapeFromNative(native_cursor));
+  auto font_it = font_cursors_.find(id);
+  if (font_it != font_cursors_.end())
+    return font_it->second;
+  auto image_it = image_cursors_.find(id);
+  if (image_it != image_cursors_.end()) {
+    if (image_it->second->scale == scale() &&
+        image_it->second->rotation == rotation()) {
+      return image_it->second->cursor;
+    } else {
+      image_cursors_.erase(image_it);
+    }
+  }
+
+  // First try to load the cursor directly.
+  ::Cursor cursor = XcursorLibraryLoadCursor(display_, css_name);

[sadrul, 2016/11/17 16:17:03]

When you say 'directly', do you mean like there can be a cursor.ico file with
the css-name and X11 will load that, or something like that?

[Tom (Use chromium acct), 2016/11/17 19:17:48]

That's right

+  if (cursor == None) {
+    // Try a similar cursor supplied by the native cursor theme.
+    for (const auto& mapping : kCursorFallbacks) {
+      if (strcmp(mapping.css_name, css_name) == 0) {
+        if (mapping.traditional_name)
+          cursor = XcursorLibraryLoadCursor(display_, mapping.traditional_name);
+        if (cursor == None && mapping.shape)
+          cursor = XCreateFontCursor(display_, mapping.shape);
+      }
+    }
+  }
+  if (cursor != None) {
+    font_cursors_[id] = cursor;
+    return cursor;
+  }
+
+  // If the theme is missing the desired cursor, use a chromium-supplied
+  // fallback icon.
+  int resource_id;
+  gfx::Point point;
+  if (ui::GetCursorDataFor(ui::CURSOR_SET_NORMAL, id, scale(), &resource_id,
+                           &point)) {
+    LoadImageCursor(id, resource_id, point);
+    return image_cursors_[id]->cursor;
+  }
+
+  // As a last resort, return a left pointer.
+  cursor = XCreateFontCursor(display_, XC_left_ptr);
+  DCHECK(cursor);
+  font_cursors_[id] = cursor;
+  return cursor;
 }
 
 }  // namespace ui