Support custom cursors for windowless plugins on Windows Aura.

webkit/glue/webcursor.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 "webkit/glue/webcursor.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCursorInfo.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebImage.h"
 
 using WebKit::WebCursorInfo;
 using WebKit::WebImage;
 
 static const int kMaxCursorDimension = 1024;
 
 WebCursor::WebCursor()
     : type_(WebCursorInfo::TypePointer) {
+#if defined(OS_WIN)
+  external_cursor_ = NULL;
+#endif
   InitPlatformData();
 }
 
 WebCursor::WebCursor(const WebCursorInfo& cursor_info)
     : type_(WebCursorInfo::TypePointer) {
+#if defined(OS_WIN)
+  external_cursor_ = NULL;
+#endif
   InitPlatformData();
   InitFromCursorInfo(cursor_info);
 }
 
 WebCursor::~WebCursor() {
   Clear();
 }
 
 WebCursor::WebCursor(const WebCursor& other) {
   InitPlatformData();
   Copy(other);
 }
 
 const WebCursor& WebCursor::operator=(const WebCursor& other) {
   if (this == &other)
     return *this;
 
   Clear();
   Copy(other);
   return *this;
 }
 
 void WebCursor::InitFromCursorInfo(const WebCursorInfo& cursor_info) {
   Clear();
 
-#if defined(OS_WIN) && !defined(USE_AURA)
+#if defined(OS_WIN)
   if (cursor_info.externalHandle) {
     InitFromExternalCursor(cursor_info.externalHandle);
     return;
   }
 #endif
 
   type_ = cursor_info.type;
   hotspot_ = cursor_info.hotSpot;
   if (IsCustom())
     SetCustomData(cursor_info.customImage);
   ClampHotspot();
 }
 
 void WebCursor::GetCursorInfo(WebCursorInfo* cursor_info) const {
   cursor_info->type = static_cast<WebCursorInfo::Type>(type_);
   cursor_info->hotSpot = hotspot_;
   ImageFromCustomData(&cursor_info->customImage);
 
-#if defined(OS_WIN) && !defined(USE_AURA)
+#if defined(OS_WIN)
   cursor_info->externalHandle = external_cursor_;
 #endif
 }
 
 bool WebCursor::Deserialize(PickleIterator* iter) {
   int type, hotspot_x, hotspot_y, size_x, size_y, data_len;
 
   const char* data;
 
   // Leave |this| unmodified unless we are going to return success.
@@ skipping 61 matching lines @@
     return false;
 
   if (!IsPlatformDataEqual(other))
     return false;
 
   return hotspot_ == other.hotspot_ &&
          custom_size_ == other.custom_size_ &&
          custom_data_ == other.custom_data_;
 }
 
+#if defined(OS_WIN)
+
+static WebCursorInfo::Type ToCursorType(HCURSOR cursor) {
+  static struct {
+    HCURSOR cursor;
+    WebCursorInfo::Type type;
+  } kStandardCursors[] = {
+    { LoadCursor(NULL, IDC_ARROW),       WebCursorInfo::TypePointer },
+    { LoadCursor(NULL, IDC_CROSS),       WebCursorInfo::TypeCross },
+    { LoadCursor(NULL, IDC_HAND),        WebCursorInfo::TypeHand },
+    { LoadCursor(NULL, IDC_IBEAM),       WebCursorInfo::TypeIBeam },
+    { LoadCursor(NULL, IDC_WAIT),        WebCursorInfo::TypeWait },
+    { LoadCursor(NULL, IDC_HELP),        WebCursorInfo::TypeHelp },
+    { LoadCursor(NULL, IDC_SIZENESW),    WebCursorInfo::TypeNorthEastResize },
+    { LoadCursor(NULL, IDC_SIZENWSE),    WebCursorInfo::TypeNorthWestResize },
+    { LoadCursor(NULL, IDC_SIZENS),      WebCursorInfo::TypeNorthSouthResize },
+    { LoadCursor(NULL, IDC_SIZEWE),      WebCursorInfo::TypeEastWestResize },
+    { LoadCursor(NULL, IDC_SIZEALL),     WebCursorInfo::TypeMove },
+    { LoadCursor(NULL, IDC_APPSTARTING), WebCursorInfo::TypeProgress },
+    { LoadCursor(NULL, IDC_NO),          WebCursorInfo::TypeNotAllowed },
+  };
+  for (int i = 0; i < arraysize(kStandardCursors); i++) {

[tony, 2012/09/12 18:58:09]

Nit: ++i

[jam, 2012/09/12 19:40:11]

Done.

+    if (cursor == kStandardCursors[i].cursor)
+      return kStandardCursors[i].type;
+  }
+  return WebCursorInfo::TypeCustom;
+}
+
+void WebCursor::InitFromExternalCursor(HCURSOR cursor) {
+  WebCursorInfo::Type cursor_type = ToCursorType(cursor);
+
+  InitFromCursorInfo(WebCursorInfo(cursor_type));
+
+  if (cursor_type == WebCursorInfo::TypeCustom)
+    external_cursor_ = cursor;
+}
+
+#endif  // defined(OS_WIN)
+
 void WebCursor::Clear() {
   type_ = WebCursorInfo::TypePointer;
   hotspot_.set_x(0);
   hotspot_.set_y(0);
   custom_size_.set_width(0);
   custom_size_.set_height(0);
   custom_data_.clear();
   CleanupPlatformData();
 }
 
@@ skipping 37 matching lines @@
 void WebCursor::ClampHotspot() {
   if (!IsCustom())
     return;
 
   // Clamp the hotspot to the custom image's dimensions.
   hotspot_.set_x(std::max(0,
                           std::min(custom_size_.width() - 1, hotspot_.x())));
   hotspot_.set_y(std::max(0,
                           std::min(custom_size_.height() - 1, hotspot_.y())));
 }