Implement large cursors in Mushrome.

ui/base/cursor/cursors_aura.cc

 // Copyright (c) 2013 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/cursors_aura.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 15 matching lines @@
   int y;
 };
 
 struct CursorData {
   CursorType id;
   int resource_id;
   HotPoint hot_1x;
   HotPoint hot_2x;
 };
 
-struct CursorSet {
-  const CursorSetType id;
+struct CursorSizeData {
+  const CursorSize id;
   const CursorData* cursors;
   const int length;
   const CursorData* animated_cursors;
   const int animated_length;
 };
 
 const CursorData kNormalCursors[] = {
     {CursorType::kNull, IDR_AURA_CURSOR_PTR, {4, 4}, {7, 7}},
     {CursorType::kPointer, IDR_AURA_CURSOR_PTR, {4, 4}, {7, 7}},
     {CursorType::kNoDrop, IDR_AURA_CURSOR_NO_DROP, {9, 9}, {18, 18}},
@@ skipping 147 matching lines @@
      {64, 62}},
     {CursorType::kGrab, IDR_AURA_CURSOR_BIG_GRAB, {21, 11}, {42, 22}},
     {CursorType::kGrabbing, IDR_AURA_CURSOR_BIG_GRABBING, {20, 12}, {40, 24}},
 };
 
 const CursorData kAnimatedCursors[] = {
     {CursorType::kWait, IDR_AURA_CURSOR_THROBBER, {7, 7}, {14, 14}},
     {CursorType::kProgress, IDR_AURA_CURSOR_THROBBER, {7, 7}, {14, 14}},
 };
 
-const CursorSet kCursorSets[] = {
-  {
-    CURSOR_SET_NORMAL,
-    kNormalCursors, arraysize(kNormalCursors),
-    kAnimatedCursors, arraysize(kAnimatedCursors)
-  },
-  {
-    CURSOR_SET_LARGE,
-    kLargeCursors, arraysize(kLargeCursors),
-    // TODO(yoshiki): Replace animated cursors with big assets. crbug.com/247254
-    kAnimatedCursors, arraysize(kAnimatedCursors)
-  },
+const CursorSizeData kCursorSizes[] = {
+    {CursorSize::kNormal, kNormalCursors, arraysize(kNormalCursors),
+     kAnimatedCursors, arraysize(kAnimatedCursors)},
+    {CursorSize::kLarge, kLargeCursors, arraysize(kLargeCursors),
+     // TODO(yoshiki): Replace animated cursors with big assets.
+     // crbug.com/247254
+     kAnimatedCursors, arraysize(kAnimatedCursors)},
 };
 
-const CursorSet* GetCursorSetByType(CursorSetType cursor_set_id) {
-  for (size_t i = 0; i < arraysize(kCursorSets); ++i) {
-    if (kCursorSets[i].id == cursor_set_id)
-      return &kCursorSets[i];
+const CursorSizeData* GetCursorSizeByType(CursorSize cursor_size) {
+  for (size_t i = 0; i < arraysize(kCursorSizes); ++i) {
+    if (kCursorSizes[i].id == cursor_size)
+      return &kCursorSizes[i];
   }
 
   return NULL;
 }
 
 bool SearchTable(const CursorData* table,
                  size_t table_length,
                  CursorType id,
                  float scale_factor,
                  int* resource_id,
                  gfx::Point* point) {
   bool resource_2x_available =
       ResourceBundle::GetSharedInstance().GetMaxScaleFactor() ==
       SCALE_FACTOR_200P;
   for (size_t i = 0; i < table_length; ++i) {
     if (table[i].id == id) {
       *resource_id = table[i].resource_id;
       *point = scale_factor == 1.0f || !resource_2x_available ?
                gfx::Point(table[i].hot_1x.x, table[i].hot_1x.y) :
                gfx::Point(table[i].hot_2x.x, table[i].hot_2x.y);
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace
 
-bool GetCursorDataFor(CursorSetType cursor_set_id,
+bool GetCursorDataFor(CursorSize cursor_size,
                       CursorType id,
                       float scale_factor,
                       int* resource_id,
                       gfx::Point* point) {
-  const CursorSet* cursor_set = GetCursorSetByType(cursor_set_id);
+  const CursorSizeData* cursor_set = GetCursorSizeByType(cursor_size);
   if (cursor_set &&
       SearchTable(cursor_set->cursors,
                   cursor_set->length,
                   id, scale_factor, resource_id, point)) {
       return true;
   }
 
   // Falls back to the default cursor set.
-  cursor_set = GetCursorSetByType(ui::CURSOR_SET_NORMAL);
+  cursor_set = GetCursorSizeByType(ui::CursorSize::kNormal);
   DCHECK(cursor_set);
   return SearchTable(cursor_set->cursors,
                      cursor_set->length,
                      id, scale_factor, resource_id, point);
 }
 
-bool GetAnimatedCursorDataFor(CursorSetType cursor_set_id,
+bool GetAnimatedCursorDataFor(CursorSize cursor_size,
                               CursorType id,
                               float scale_factor,
                               int* resource_id,
                               gfx::Point* point) {
-  const CursorSet* cursor_set = GetCursorSetByType(cursor_set_id);
+  const CursorSizeData* cursor_set = GetCursorSizeByType(cursor_size);
   if (cursor_set &&
       SearchTable(cursor_set->animated_cursors,
                   cursor_set->animated_length,
                   id, scale_factor, resource_id, point)) {
     return true;
   }
 
   // Falls back to the default cursor set.
-  cursor_set = GetCursorSetByType(ui::CURSOR_SET_NORMAL);
+  cursor_set = GetCursorSizeByType(ui::CursorSize::kNormal);
   DCHECK(cursor_set);
   return SearchTable(cursor_set->animated_cursors,
                      cursor_set->animated_length,
                      id, scale_factor, resource_id, point);
 }
 
 bool GetCursorBitmap(const Cursor& cursor,
                      SkBitmap* bitmap,
                      gfx::Point* point) {
   DCHECK(bitmap && point);
 #if defined(OS_WIN)
   Cursor cursor_copy = cursor;
   ui::CursorLoaderWin cursor_loader;
   cursor_loader.SetPlatformCursor(&cursor_copy);
   const std::unique_ptr<SkBitmap> cursor_bitmap(
       IconUtil::CreateSkBitmapFromHICON(cursor_copy.platform()));
   *point = IconUtil::GetHotSpotFromHICON(cursor_copy.platform());
 #else
   int resource_id;
-  if (!GetCursorDataFor(ui::CURSOR_SET_NORMAL,
-                        cursor.native_type(),
-                        cursor.device_scale_factor(),
-                        &resource_id,
-                        point)) {
+  if (!GetCursorDataFor(ui::CursorSize::kNormal, cursor.native_type(),
+                        cursor.device_scale_factor(), &resource_id, point)) {
     return false;
   }
 
   const SkBitmap* cursor_bitmap = ResourceBundle::GetSharedInstance().
       GetImageSkiaNamed(resource_id)->bitmap();
 #endif
   if (!cursor_bitmap)
     return false;
   *bitmap = *cursor_bitmap;
   return true;
 }
 
 }  // namespace ui