BASELINE: Update Chromium to 90.0.4430.221

Change-Id: Iff4d9d18d2fcf1a576f3b1f453010f744a232920
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

21 files changed, 415 insertions, 257 deletions

diff --git a/chromium/ui/base/cursor/BUILD.gn b/chromium/ui/base/cursor/BUILD.gn
index 947ff85b6ef..23ebb70fbf3 100644
--- a/chromium/ui/base/cursor/BUILD.gn
+++ b/chromium/ui/base/cursor/BUILD.gn
@@ -24,12 +24,8 @@ component("cursor_base") {
   ]
   deps = [ "//ui/gfx:geometry_skia" ]
 
-  if (is_win) {
-    sources += [ "cursor_win.cc" ]
-  }
-
-  if (use_x11 || use_ozone) {
-    sources += [ "cursor_ozone.cc" ]
+  if (use_aura) {
+    sources += [ "cursor_aura.cc" ]
   }
 }
 
@@ -48,6 +44,7 @@ if (use_aura) {
   component("cursor") {
     output_name = "ui_base_cursor"
     sources = [
+      "cursor_loader.cc",
       "cursor_loader.h",
       "cursor_lookup.cc",
       "cursor_lookup.h",
@@ -75,8 +72,10 @@ if (use_aura) {
 
     if (is_win) {
       sources += [
-        "cursor_loader_win.cc",
-        "cursor_loader_win.h",
+        "win/win_cursor.cc",
+        "win/win_cursor.h",
+        "win/win_cursor_factory.cc",
+        "win/win_cursor_factory.h",
       ]
       deps += [ "//ui/resources:ui_unscaled_resources_grd" ]
     }
@@ -92,13 +91,6 @@ if (use_aura) {
       ]
       deps += [ "//build:chromeos_buildflags" ]
     }
-
-    if (use_x11 || use_ozone) {
-      sources += [
-        "cursor_loader_ozone.cc",
-        "cursor_loader_ozone.h",
-      ]
-    }
   }
 }
 
diff --git a/chromium/ui/base/cursor/cursor.h b/chromium/ui/base/cursor/cursor.h
index 1c54756715d..e5ffd67ffa3 100644
--- a/chromium/ui/base/cursor/cursor.h
+++ b/chromium/ui/base/cursor/cursor.h
@@ -17,13 +17,10 @@
 
 namespace ui {
 
-#if defined(OS_WIN)
-typedef ::HCURSOR PlatformCursor;
-#else
 // NOTE: On Ozone platforms, the type is chosen at runtime, and is either
 // X11Cursor* or BitmapCursorOzone*.
-typedef void* PlatformCursor;
-#endif
+// On Windows, it's WinCursor*.
+using PlatformCursor = void*;
 
 // Ref-counted cursor that supports both default and custom cursors.
 class COMPONENT_EXPORT(UI_BASE_CURSOR_BASE) Cursor {
diff --git a/chromium/ui/base/cursor/cursor_ozone.cc b/chromium/ui/base/cursor/cursor_aura.cc
index b41f4ca3b67..b41f4ca3b67 100644
--- a/chromium/ui/base/cursor/cursor_ozone.cc
+++ b/chromium/ui/base/cursor/cursor_aura.cc
diff --git a/chromium/ui/base/cursor/cursor_factory.cc b/chromium/ui/base/cursor/cursor_factory.cc
index 5a987bf501a..65afecadbb6 100644
--- a/chromium/ui/base/cursor/cursor_factory.cc
+++ b/chromium/ui/base/cursor/cursor_factory.cc
@@ -9,6 +9,7 @@
 #include "base/check.h"
 #include "base/check_op.h"
 #include "base/notreached.h"
+#include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
 
 namespace ui {
 
@@ -67,4 +68,123 @@ void CursorFactory::ObserveThemeChanges() {
   NOTIMPLEMENTED();
 }
 
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+
+// Returns a cursor name compatible with either X11 or the FreeDesktop.org
+// cursor spec ([1] and [2]), followed by fallbacks that can work as
+// replacements in some environments where the original may not be available
+// (e.g. desktop environments other than GNOME and KDE).
+//
+// TODO(hferreiro): each list starts with the FreeDesktop.org icon name but
+// "ns-resize", "ew-resize", "nesw-resize", "nwse-resize", "grab", "grabbing",
+// which were not available in older versions of Breeze, the default KDE theme.
+//
+// [1]
+// https://www.x.org/releases/current/doc/libX11/libX11/libX11.html#x_font_cursors
+// [2] https://www.freedesktop.org/wiki/Specifications/cursor-spec/
+std::vector<std::string> CursorNamesFromType(mojom::CursorType type) {
+  switch (type) {
+    case mojom::CursorType::kMove:
+      // Returning "move" is the correct thing here, but Blink doesn't make a
+      // distinction between move and all-scroll.  Other platforms use a cursor
+      // more consistent with all-scroll, so use that.
+    case mojom::CursorType::kMiddlePanning:
+    case mojom::CursorType::kMiddlePanningVertical:
+    case mojom::CursorType::kMiddlePanningHorizontal:
+      return {"all-scroll", "fleur"};
+    case mojom::CursorType::kEastPanning:
+    case mojom::CursorType::kEastResize:
+      return {"e-resize", "right_side"};
+    case mojom::CursorType::kNorthPanning:
+    case mojom::CursorType::kNorthResize:
+      return {"n-resize", "top_side"};
+    case mojom::CursorType::kNorthEastPanning:
+    case mojom::CursorType::kNorthEastResize:
+      return {"ne-resize", "top_right_corner"};
+    case mojom::CursorType::kNorthWestPanning:
+    case mojom::CursorType::kNorthWestResize:
+      return {"nw-resize", "top_left_corner"};
+    case mojom::CursorType::kSouthPanning:
+    case mojom::CursorType::kSouthResize:
+      return {"s-resize", "bottom_side"};
+    case mojom::CursorType::kSouthEastPanning:
+    case mojom::CursorType::kSouthEastResize:
+      return {"se-resize", "bottom_right_corner"};
+    case mojom::CursorType::kSouthWestPanning:
+    case mojom::CursorType::kSouthWestResize:
+      return {"sw-resize", "bottom_left_corner"};
+    case mojom::CursorType::kWestPanning:
+    case mojom::CursorType::kWestResize:
+      return {"w-resize", "left_side"};
+    case mojom::CursorType::kNone:
+      return {"none"};
+    case mojom::CursorType::kGrab:
+      return {"openhand", "grab"};
+    case mojom::CursorType::kGrabbing:
+      return {"closedhand", "grabbing", "hand2"};
+    case mojom::CursorType::kCross:
+      return {"crosshair", "cross"};
+    case mojom::CursorType::kHand:
+      return {"pointer", "hand", "hand2"};
+    case mojom::CursorType::kIBeam:
+      return {"text", "xterm"};
+    case mojom::CursorType::kProgress:
+      return {"progress", "left_ptr_watch", "watch"};
+    case mojom::CursorType::kWait:
+      return {"wait", "watch"};
+    case mojom::CursorType::kHelp:
+      return {"help"};
+    case mojom::CursorType::kNorthSouthResize:
+      return {"sb_v_double_arrow", "ns-resize"};
+    case mojom::CursorType::kEastWestResize:
+      return {"sb_h_double_arrow", "ew-resize"};
+    case mojom::CursorType::kColumnResize:
+      return {"col-resize", "sb_h_double_arrow"};
+    case mojom::CursorType::kRowResize:
+      return {"row-resize", "sb_v_double_arrow"};
+    case mojom::CursorType::kNorthEastSouthWestResize:
+      return {"size_bdiag", "nesw-resize", "fd_double_arrow"};
+    case mojom::CursorType::kNorthWestSouthEastResize:
+      return {"size_fdiag", "nwse-resize", "bd_double_arrow"};
+    case mojom::CursorType::kVerticalText:
+      return {"vertical-text"};
+    case mojom::CursorType::kZoomIn:
+      return {"zoom-in"};
+    case mojom::CursorType::kZoomOut:
+      return {"zoom-out"};
+    case mojom::CursorType::kCell:
+      return {"cell", "plus"};
+    case mojom::CursorType::kContextMenu:
+      return {"context-menu"};
+    case mojom::CursorType::kAlias:
+      return {"alias"};
+    case mojom::CursorType::kNoDrop:
+      return {"no-drop"};
+    case mojom::CursorType::kCopy:
+      return {"copy"};
+    case mojom::CursorType::kNotAllowed:
+      return {"not-allowed", "crossed_circle"};
+    case mojom::CursorType::kDndNone:
+      return {"dnd-none", "hand2"};
+    case mojom::CursorType::kDndMove:
+      return {"dnd-move", "hand2"};
+    case mojom::CursorType::kDndCopy:
+      return {"dnd-copy", "hand2"};
+    case mojom::CursorType::kDndLink:
+      return {"dnd-link", "hand2"};
+    case mojom::CursorType::kCustom:
+      // kCustom is for custom image cursors. The platform cursor will be set
+      // at WebCursor::GetNativeCursor().
+      NOTREACHED();
+      FALLTHROUGH;
+    case mojom::CursorType::kNull:
+    case mojom::CursorType::kPointer:
+      return {"left_ptr"};
+  }
+  NOTREACHED();
+  return {"left_ptr"};
+}
+
+#endif  // defined(OS_LINUX) || defined(OS_CHROMEOS)
+
 }  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_factory.h b/chromium/ui/base/cursor/cursor_factory.h
index 57c70c9e60a..7de026b856b 100644
--- a/chromium/ui/base/cursor/cursor_factory.h
+++ b/chromium/ui/base/cursor/cursor_factory.h
@@ -9,6 +9,7 @@
 
 #include "base/component_export.h"
 #include "base/optional.h"
+#include "build/build_config.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
 
 class SkBitmap;
@@ -66,6 +67,11 @@ class COMPONENT_EXPORT(UI_BASE_CURSOR_BASE) CursorFactory {
   virtual void ObserveThemeChanges();
 };
 
+#if defined(OS_LINUX) || defined(OS_CHROMEOS)
+COMPONENT_EXPORT(UI_BASE_CURSOR_BASE)
+std::vector<std::string> CursorNamesFromType(mojom::CursorType type);
+#endif
+
 }  // namespace ui
 
 #endif  // UI_BASE_CURSOR_CURSOR_FACTORY_H_
diff --git a/chromium/ui/base/cursor/cursor_loader_ozone.cc b/chromium/ui/base/cursor/cursor_loader.cc
index 6d386672c9e..20544e2d3f4 100644
--- a/chromium/ui/base/cursor/cursor_loader_ozone.cc
+++ b/chromium/ui/base/cursor/cursor_loader.cc
@@ -1,18 +1,19 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2021 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_ozone.h"
+#include "ui/base/cursor/cursor_loader.h"
 
-#include <memory>
+#include <map>
 #include <vector>
 
-#include "base/ranges/algorithm.h"
+#include "base/check.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/cursor_factory.h"
 #include "ui/base/cursor/cursor_size.h"
 #include "ui/base/cursor/cursor_util.h"
 #include "ui/base/cursor/cursors_aura.h"
-#include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
+#include "ui/base/cursor/mojom/cursor_type.mojom.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace ui {
@@ -26,33 +27,52 @@ const int kAnimatedCursorFrameDelayMs = 25;
 
 }  // namespace
 
-CursorLoaderOzone::CursorLoaderOzone(bool use_platform_cursors)
+CursorLoader::CursorLoader(bool use_platform_cursors)
     : use_platform_cursors_(use_platform_cursors),
       factory_(CursorFactory::GetInstance()) {}
 
-CursorLoaderOzone::~CursorLoaderOzone() {
+CursorLoader::~CursorLoader() {
   UnloadCursors();
 }
 
-void CursorLoaderOzone::UnloadCursors() {
+void CursorLoader::UnloadCursors() {
   for (const auto& image_cursor : image_cursors_)
     factory_->UnrefImageCursor(image_cursor.second);
   image_cursors_.clear();
 }
 
-void CursorLoaderOzone::SetPlatformCursor(gfx::NativeCursor* cursor) {
+bool CursorLoader::SetDisplayData(display::Display::Rotation rotation,
+                                  float scale) {
+  if (rotation_ == rotation && scale_ == scale)
+    return false;
+
+  rotation_ = rotation;
+  scale_ = scale;
+  UnloadCursors();
+  return true;
+}
+
+void CursorLoader::SetSize(CursorSize size) {
+  if (size_ == size)
+    return;
+
+  size_ = size;
+  UnloadCursors();
+}
+
+void CursorLoader::SetPlatformCursor(Cursor* cursor) {
   DCHECK(cursor);
 
-  // The platform cursor was already set via WebCursor::GetPlatformCursor.
+  // The platform cursor was already set via WebCursor::GetNativeCursor.
   if (cursor->type() == mojom::CursorType::kCustom)
     return;
   cursor->set_image_scale_factor(scale());
   cursor->SetPlatformCursor(CursorFromType(cursor->type()));
 }
 
-void CursorLoaderOzone::LoadImageCursor(mojom::CursorType type,
-                                        int resource_id,
-                                        const gfx::Point& hot) {
+void CursorLoader::LoadImageCursor(mojom::CursorType type,
+                                   int resource_id,
+                                   const gfx::Point& hot) {
   gfx::Point hotspot = hot;
   if (base::ranges::count(kAnimatedCursorTypes, type) == 0) {
     SkBitmap bitmap;
@@ -67,7 +87,7 @@ void CursorLoaderOzone::LoadImageCursor(mojom::CursorType type,
   }
 }
 
-PlatformCursor CursorLoaderOzone::CursorFromType(mojom::CursorType type) {
+PlatformCursor CursorLoader::CursorFromType(mojom::CursorType type) {
   // An image cursor is loaded for this type.
   if (image_cursors_.count(type))
     return image_cursors_[type];
@@ -80,6 +100,7 @@ PlatformCursor CursorLoaderOzone::CursorFromType(mojom::CursorType type) {
         factory_->GetDefaultCursor(type);
     if (default_cursor)
       return *default_cursor;
+    LOG(ERROR) << "Failed to load a platform cursor of type " << type;
   }
 
   // Loads the default Aura cursor bitmap for the cursor type. Falls back on
@@ -94,8 +115,7 @@ PlatformCursor CursorLoaderOzone::CursorFromType(mojom::CursorType type) {
   return platform;
 }
 
-// Gets default Aura cursor bitmap/hotspot and creates a PlatformCursor with it.
-PlatformCursor CursorLoaderOzone::LoadCursorFromAsset(mojom::CursorType type) {
+PlatformCursor CursorLoader::LoadCursorFromAsset(mojom::CursorType type) {
   int resource_id;
   gfx::Point hotspot;
   if (GetCursorDataFor(size(), type, scale(), &resource_id, &hotspot)) {
@@ -105,8 +125,4 @@ PlatformCursor CursorLoaderOzone::LoadCursorFromAsset(mojom::CursorType type) {
   return nullptr;
 }
 
-std::unique_ptr<CursorLoader> CursorLoader::Create(bool use_platform_cursors) {
-  return std::make_unique<CursorLoaderOzone>(use_platform_cursors);
-}
-
 }  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_loader.h b/chromium/ui/base/cursor/cursor_loader.h
index 0c516d7fa7c..767758e1619 100644
--- a/chromium/ui/base/cursor/cursor_loader.h
+++ b/chromium/ui/base/cursor/cursor_loader.h
@@ -5,22 +5,28 @@
 #ifndef UI_BASE_CURSOR_CURSOR_LOADER_H_
 #define UI_BASE_CURSOR_CURSOR_LOADER_H_
 
+#include <map>
 #include <memory>
 
 #include "base/component_export.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/cursor_size.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
 #include "ui/display/display.h"
-#include "ui/gfx/native_widget_types.h"
+
+namespace gfx {
+class Point;
+}
 
 namespace ui {
+class CursorFactory;
 
 class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoader {
  public:
-  CursorLoader() = default;
+  explicit CursorLoader(bool use_platform_cursors = true);
   CursorLoader(const CursorLoader&) = delete;
   CursorLoader& operator=(const CursorLoader&) = delete;
-  virtual ~CursorLoader() = default;
+  ~CursorLoader();
 
   // Returns the rotation and scale of the currently loaded cursor.
   display::Display::Rotation rotation() const { return rotation_; }
@@ -28,39 +34,34 @@ class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoader {
 
   // Sets the rotation and scale the cursors are loaded for.
   // Returns true if the cursor image was reloaded.
-  bool SetDisplayData(display::Display::Rotation rotation, float scale) {
-    if (rotation_ == rotation && scale_ == scale)
-      return false;
-
-    rotation_ = rotation;
-    scale_ = scale;
-    UnloadCursors();
-    return true;
-  }
+  bool SetDisplayData(display::Display::Rotation rotation, float scale);
 
   // Returns the size of the currently loaded cursor.
   CursorSize size() const { return size_; }
 
   // Sets the size of the mouse cursor icon.
-  void set_size(CursorSize size) {
-    if (size_ == size)
-      return;
+  void SetSize(CursorSize size);
 
-    size_ = size;
-    UnloadCursors();
-  }
+  // Sets the platform cursor based on the type of |cursor|.
+  void SetPlatformCursor(Cursor* cursor);
 
-  // Sets the platform cursor based on the native type of |cursor|.
-  virtual void SetPlatformCursor(gfx::NativeCursor* cursor) = 0;
+ private:
+  // Resets the cursor cache.
+  void UnloadCursors();
+  void LoadImageCursor(mojom::CursorType id,
+                       int resource_id,
+                       const gfx::Point& hot);
+  PlatformCursor CursorFromType(mojom::CursorType type);
+  PlatformCursor LoadCursorFromAsset(mojom::CursorType type);
 
-  // Creates a CursorLoader.
-  static std::unique_ptr<CursorLoader> Create(bool use_platform_cursors = true);
+  // Whether to use cursors provided by the underlying platform (e.g. X11
+  // cursors). If false or in the case of a failure, Chromium assets will be
+  // used instead.
+  const bool use_platform_cursors_;
 
- protected:
-  // Resets the cursor cache.
-  virtual void UnloadCursors() = 0;
+  std::map<mojom::CursorType, PlatformCursor> image_cursors_;
+  CursorFactory* factory_ = nullptr;
 
- private:
   // The current scale of the mouse cursor icon.
   float scale_ = 1.0f;
 
diff --git a/chromium/ui/base/cursor/cursor_loader_ozone.h b/chromium/ui/base/cursor/cursor_loader_ozone.h
deleted file mode 100644
index bf1c11f6afb..00000000000
--- a/chromium/ui/base/cursor/cursor_loader_ozone.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2014 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.
-
-#ifndef UI_BASE_CURSOR_CURSOR_LOADER_OZONE_H_
-#define UI_BASE_CURSOR_CURSOR_LOADER_OZONE_H_
-
-#include <map>
-
-#include "base/component_export.h"
-#include "base/macros.h"
-#include "ui/base/cursor/cursor.h"
-#include "ui/base/cursor/cursor_loader.h"
-#include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
-
-namespace gfx {
-class Point;
-}
-
-namespace ui {
-class CursorFactory;
-
-class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoaderOzone : public CursorLoader {
- public:
-  explicit CursorLoaderOzone(bool use_platform_cursors);
-  ~CursorLoaderOzone() override;
-
-  // CursorLoader overrides:
-  void SetPlatformCursor(gfx::NativeCursor* cursor) override;
-
- private:
-  // CursorLoader overrides:
-  void UnloadCursors() override;
-
-  void LoadImageCursor(mojom::CursorType id,
-                       int resource_id,
-                       const gfx::Point& hot);
-  PlatformCursor CursorFromType(mojom::CursorType type);
-  PlatformCursor LoadCursorFromAsset(mojom::CursorType type);
-
-  // Whether to use cursors provided by the underlying platform (e.g. X11
-  // cursors). If false or in the case of a failure, Chromium assets will be
-  // used instead.
-  const bool use_platform_cursors_;
-
-  // Pointers are owned by ResourceBundle and must not be freed here.
-  std::map<mojom::CursorType, PlatformCursor> image_cursors_;
-  CursorFactory* factory_ = nullptr;
-
-  DISALLOW_COPY_AND_ASSIGN(CursorLoaderOzone);
-};
-
-}  // namespace ui
-
-#endif  // UI_BASE_CURSOR_CURSOR_LOADER_OZONE_H_
diff --git a/chromium/ui/base/cursor/cursor_loader_unittest.cc b/chromium/ui/base/cursor/cursor_loader_unittest.cc
index 67b4c2be1ce..a609fa4e554 100644
--- a/chromium/ui/base/cursor/cursor_loader_unittest.cc
+++ b/chromium/ui/base/cursor/cursor_loader_unittest.cc
@@ -4,10 +4,17 @@
 
 #include "ui/base/cursor/cursor_loader.h"
 
+#include "base/memory/scoped_refptr.h"
+#include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
 
+#if defined(OS_WIN)
+#include "ui/base/cursor/win/win_cursor.h"
+#include "ui/base/cursor/win/win_cursor_factory.h"
+#endif
+
 #if defined(USE_OZONE)
 #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h"
 #endif
@@ -23,25 +30,32 @@ namespace ui {
 namespace {
 
 PlatformCursor LoadInvisibleCursor() {
-  auto cursor_loader = CursorLoader::Create();
+  CursorLoader cursor_loader;
   Cursor cursor(mojom::CursorType::kNone);
-  cursor_loader->SetPlatformCursor(&cursor);
+  cursor_loader.SetPlatformCursor(&cursor);
   return cursor.platform();
 }
 
 }  // namespace
 
-#if !defined(USE_X11)
-TEST(CursorLoaderTest, InvisibleCursorOnNotX11) {
-#if defined(USE_OZONE)
-  BitmapCursorFactoryOzone cursor_factory;
+#if defined(OS_WIN)
+TEST(CursorLoaderTest, InvisibleCursor) {
+  WinCursorFactory cursor_factory;
+  auto* invisible_cursor = static_cast<WinCursor*>(LoadInvisibleCursor());
+  ASSERT_NE(invisible_cursor, nullptr);
+  EXPECT_EQ(invisible_cursor->hcursor(), nullptr);
+}
 #endif
+
+#if defined(USE_OZONE) && !defined(USE_X11)
+TEST(CursorLoaderTest, InvisibleCursor) {
+  BitmapCursorFactoryOzone cursor_factory;
   EXPECT_EQ(LoadInvisibleCursor(), nullptr);
 }
 #endif
 
 #if defined(USE_X11)
-TEST(CursorLoaderTest, InvisibleCursorOnX11) {
+TEST(CursorLoaderTest, InvisibleCursor) {
   X11CursorFactory cursor_factory;
   // Building an image cursor with an invalid SkBitmap should return the
   // invisible cursor in X11.
diff --git a/chromium/ui/base/cursor/cursor_loader_win.h b/chromium/ui/base/cursor/cursor_loader_win.h
deleted file mode 100644
index cbe7d000138..00000000000
--- a/chromium/ui/base/cursor/cursor_loader_win.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// 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.
-
-#ifndef UI_BASE_CURSOR_CURSOR_LOADER_WIN_H_
-#define UI_BASE_CURSOR_CURSOR_LOADER_WIN_H_
-
-#include "base/component_export.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "ui/base/cursor/cursor_loader.h"
-
-namespace ui {
-
-class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoaderWin : public CursorLoader {
- public:
-  CursorLoaderWin();
-  ~CursorLoaderWin() override;
-
-  // Overridden from CursorLoader:
-  void UnloadCursors() override;
-  void SetPlatformCursor(gfx::NativeCursor* cursor) override;
-
-  // Used to pass the cursor resource module name to the cursor loader. This is
-  // typically used to load non system cursors.
-  static void SetCursorResourceModule(const base::string16& module_name);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(CursorLoaderWin);
-};
-
-}  // namespace ui
-
-#endif  // UI_BASE_CURSOR_CURSOR_LOADER_WIN_H_
diff --git a/chromium/ui/base/cursor/cursor_util.cc b/chromium/ui/base/cursor/cursor_util.cc
index ee513696649..57b1bb6dcbc 100644
--- a/chromium/ui/base/cursor/cursor_util.cc
+++ b/chromium/ui/base/cursor/cursor_util.cc
@@ -99,8 +99,9 @@ void ScaleAndRotateCursorBitmapAndHotpoint(float scale,
   scaled_bitmap.setInfo(
       bitmap->info().makeWH(scaled_size.width(), scaled_size.height()));
   if (scaled_bitmap.tryAllocPixels()) {
-    bitmap->pixmap().scalePixels(scaled_bitmap.pixmap(),
-                                 kMedium_SkFilterQuality);
+    bitmap->pixmap().scalePixels(
+        scaled_bitmap.pixmap(),
+        {SkFilterMode::kLinear, SkMipmapMode::kNearest});
   }
 
   *bitmap = scaled_bitmap;
diff --git a/chromium/ui/base/cursor/cursor_win.cc b/chromium/ui/base/cursor/cursor_win.cc
deleted file mode 100644
index 2d4aafea8d5..00000000000
--- a/chromium/ui/base/cursor/cursor_win.cc
+++ /dev/null
@@ -1,17 +0,0 @@
-// 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.h"
-
-namespace ui {
-
-void Cursor::RefCustomCursor() {
-  // TODO(winguru):
-}
-
-void Cursor::UnrefCustomCursor() {
-  // TODO(winguru):
-}
-
-}  // namespace ui
diff --git a/chromium/ui/base/cursor/cursors_aura.cc b/chromium/ui/base/cursor/cursors_aura.cc
index c527ac4d8eb..c63ea7594e4 100644
--- a/chromium/ui/base/cursor/cursors_aura.cc
+++ b/chromium/ui/base/cursor/cursors_aura.cc
@@ -18,7 +18,8 @@
 #include "ui/resources/grit/ui_resources.h"
 
 #if defined(OS_WIN)
-#include "ui/base/cursor/cursor_loader_win.h"
+#include "ui/base/cursor/cursor_loader.h"
+#include "ui/base/cursor/win/win_cursor.h"
 #include "ui/gfx/icon_util.h"
 #endif
 
@@ -297,9 +298,10 @@ bool GetCursorDataFor(CursorSize cursor_size,
 SkBitmap GetDefaultBitmap(const Cursor& cursor) {
 #if defined(OS_WIN)
   Cursor cursor_copy = cursor;
-  ui::CursorLoaderWin cursor_loader;
+  CursorLoader cursor_loader;
   cursor_loader.SetPlatformCursor(&cursor_copy);
-  return IconUtil::CreateSkBitmapFromHICON(cursor_copy.platform());
+  return IconUtil::CreateSkBitmapFromHICON(
+      static_cast<WinCursor*>(cursor_copy.platform())->hcursor());
 #else
   int resource_id;
   gfx::Point hotspot;
@@ -316,9 +318,10 @@ SkBitmap GetDefaultBitmap(const Cursor& cursor) {
 gfx::Point GetDefaultHotspot(const Cursor& cursor) {
 #if defined(OS_WIN)
   Cursor cursor_copy = cursor;
-  ui::CursorLoaderWin cursor_loader;
+  CursorLoader cursor_loader;
   cursor_loader.SetPlatformCursor(&cursor_copy);
-  return IconUtil::GetHotSpotFromHICON(cursor_copy.platform());
+  return IconUtil::GetHotSpotFromHICON(
+      static_cast<WinCursor*>(cursor_copy.platform())->hcursor());
 #else
   int resource_id;
   gfx::Point hotspot;
diff --git a/chromium/ui/base/cursor/mojom/cursor.mojom b/chromium/ui/base/cursor/mojom/cursor.mojom
index 56230736c31..f7852c06330 100644
--- a/chromium/ui/base/cursor/mojom/cursor.mojom
+++ b/chromium/ui/base/cursor/mojom/cursor.mojom
@@ -17,7 +17,7 @@ struct Cursor {
   gfx.mojom.Point hotspot;
 
   // The custom bitmap. Must be non-empty if |cursor_type| is kCustom.
-  skia.mojom.Bitmap? bitmap;
+  skia.mojom.BitmapN32? bitmap;
 
   // This is the image scale of this cursor.
   float image_scale_factor;
diff --git a/chromium/ui/base/cursor/mojom/cursor_mojom_traits_unittest.cc b/chromium/ui/base/cursor/mojom/cursor_mojom_traits_unittest.cc
index 88f888b2709..8c4ecc2e2f6 100644
--- a/chromium/ui/base/cursor/mojom/cursor_mojom_traits_unittest.cc
+++ b/chromium/ui/base/cursor/mojom/cursor_mojom_traits_unittest.cc
@@ -17,7 +17,8 @@ namespace ui {
 namespace {
 
 bool EchoCursor(const ui::Cursor& in, ui::Cursor* out) {
-  return mojom::Cursor::Deserialize(mojom::Cursor::Serialize(&in), out);
+  return mojom::Cursor::DeserializeFromMessage(
+      mojom::Cursor::SerializeAsMessage(&in), out);
 }
 
 using CursorStructTraitsTest = testing::Test;
diff --git a/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.cc b/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.cc
index f16c01a02a7..1fbb8d5d6ad 100644
--- a/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.cc
+++ b/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.cc
@@ -117,6 +117,10 @@ BitmapCursorOzone::BitmapCursorOzone(mojom::CursorType type,
          bitmaps_.end());
 }
 
+BitmapCursorOzone::BitmapCursorOzone(mojom::CursorType type,
+                                     void* platform_data)
+    : type_(type), platform_data_(platform_data) {}
+
 BitmapCursorOzone::~BitmapCursorOzone() = default;
 
 const gfx::Point& BitmapCursorOzone::hotspot() {
diff --git a/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h b/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h
index db049fb4532..0fa94409e0c 100644
--- a/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h
+++ b/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h
@@ -37,6 +37,9 @@ class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorOzone
                     const gfx::Point& hotspot,
                     int frame_delay_ms);
 
+  // Creates a cursor with external storage.
+  BitmapCursorOzone(mojom::CursorType type, void* platform_data);
+
   mojom::CursorType type() const { return type_; }
   const gfx::Point& hotspot();
   const SkBitmap& bitmap();
@@ -45,6 +48,9 @@ class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorOzone
   const std::vector<SkBitmap>& bitmaps();
   int frame_delay_ms();
 
+  // For theme cursors.
+  void* platform_data() { return platform_data_; }
+
  private:
   friend class base::RefCounted<BitmapCursorOzone>;
   ~BitmapCursorOzone();
@@ -54,6 +60,10 @@ class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorOzone
   gfx::Point hotspot_;
   int frame_delay_ms_;
 
+  // Platform cursor data.  Having this non-nullptr means that this cursor
+  // is supplied by the platform.
+  void* const platform_data_ = nullptr;
+
   DISALLOW_COPY_AND_ASSIGN(BitmapCursorOzone);
 };
 
@@ -61,9 +71,6 @@ class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorOzone
 //
 // This is a base class for platforms where PlatformCursor is an SkBitmap
 // combined with a gfx::Point for the hotspot.
-//
-// Subclasses need only implement SetBitmapCursor() as everything else is
-// implemented here.
 class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorFactoryOzone
     : public CursorFactory {
  public:
diff --git a/chromium/ui/base/cursor/win/win_cursor.cc b/chromium/ui/base/cursor/win/win_cursor.cc
new file mode 100644
index 00000000000..afa707faffd
--- /dev/null
+++ b/chromium/ui/base/cursor/win/win_cursor.cc
@@ -0,0 +1,19 @@
+// Copyright 2021 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/win/win_cursor.h"
+
+#include <windows.h>
+
+namespace ui {
+
+WinCursor::WinCursor(HCURSOR hcursor) {
+  hcursor_ = hcursor;
+}
+
+WinCursor::~WinCursor() {
+  DestroyIcon(hcursor_);
+}
+
+}  // namespace ui
diff --git a/chromium/ui/base/cursor/win/win_cursor.h b/chromium/ui/base/cursor/win/win_cursor.h
new file mode 100644
index 00000000000..e1f787f7710
--- /dev/null
+++ b/chromium/ui/base/cursor/win/win_cursor.h
@@ -0,0 +1,35 @@
+// Copyright 2021 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.
+
+#ifndef UI_BASE_CURSOR_WIN_WIN_CURSOR_H_
+#define UI_BASE_CURSOR_WIN_WIN_CURSOR_H_
+
+#include "base/component_export.h"
+#include "base/memory/ref_counted.h"
+#include "base/win/windows_types.h"
+
+namespace ui {
+
+// Ref counted class to hold a Windows cursor, i.e. an HCURSOR.  Clears the
+// resources on destruction.
+class COMPONENT_EXPORT(UI_BASE_CURSOR) WinCursor
+    : public base::RefCounted<WinCursor> {
+ public:
+  explicit WinCursor(HCURSOR hcursor = nullptr);
+  WinCursor(const WinCursor&) = delete;
+  WinCursor& operator=(const WinCursor&) = delete;
+
+  HCURSOR hcursor() const { return hcursor_; }
+
+ private:
+  friend class base::RefCounted<WinCursor>;
+
+  ~WinCursor();
+
+  HCURSOR hcursor_;
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CURSOR_WIN_WIN_CURSOR_H_
diff --git a/chromium/ui/base/cursor/cursor_loader_win.cc b/chromium/ui/base/cursor/win/win_cursor_factory.cc
index 392fd85d6f3..bde6a5be63f 100644
--- a/chromium/ui/base/cursor/cursor_loader_win.cc
+++ b/chromium/ui/base/cursor/win/win_cursor_factory.cc
@@ -1,30 +1,38 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2021 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_win.h"
+#include "ui/base/cursor/win/win_cursor_factory.h"
 
 #include <windows.h>
 
-#include <memory>
+#include <string>
 
-#include "base/lazy_instance.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/notreached.h"
+#include "base/optional.h"
+#include "base/win/scoped_gdi_object.h"
+#include "base/win/windows_types.h"
 #include "ui/base/cursor/cursor.h"
-#include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
+#include "ui/base/cursor/mojom/cursor_type.mojom.h"
+#include "ui/base/resource/resource_bundle_win.h"
+#include "ui/gfx/icon_util.h"
 #include "ui/resources/grit/ui_unscaled_resources.h"
 
 namespace ui {
-
 namespace {
 
-base::LazyInstance<base::string16>::DestructorAtExit
-    g_cursor_resource_module_name;
+WinCursor* ToWinCursor(PlatformCursor cursor) {
+  return static_cast<WinCursor*>(cursor);
+}
 
-const wchar_t* GetCursorId(gfx::NativeCursor native_cursor) {
-  switch (native_cursor.type()) {
+PlatformCursor ToPlatformCursor(WinCursor* cursor) {
+  return static_cast<PlatformCursor>(cursor);
+}
+
+const wchar_t* GetCursorId(mojom::CursorType type) {
+  switch (type) {
     case mojom::CursorType::kNull:
-      return IDC_ARROW;
     case mojom::CursorType::kPointer:
       return IDC_ARROW;
     case mojom::CursorType::kCross:
@@ -38,27 +46,19 @@ const wchar_t* GetCursorId(gfx::NativeCursor native_cursor) {
     case mojom::CursorType::kHelp:
       return IDC_HELP;
     case mojom::CursorType::kEastResize:
+    case mojom::CursorType::kWestResize:
+    case mojom::CursorType::kEastWestResize:
       return IDC_SIZEWE;
     case mojom::CursorType::kNorthResize:
-      return IDC_SIZENS;
-    case mojom::CursorType::kNorthEastResize:
-      return IDC_SIZENESW;
-    case mojom::CursorType::kNorthWestResize:
-      return IDC_SIZENWSE;
     case mojom::CursorType::kSouthResize:
-      return IDC_SIZENS;
-    case mojom::CursorType::kSouthEastResize:
-      return IDC_SIZENWSE;
-    case mojom::CursorType::kSouthWestResize:
-      return IDC_SIZENESW;
-    case mojom::CursorType::kWestResize:
-      return IDC_SIZEWE;
     case mojom::CursorType::kNorthSouthResize:
       return IDC_SIZENS;
-    case mojom::CursorType::kEastWestResize:
-      return IDC_SIZEWE;
+    case mojom::CursorType::kNorthEastResize:
+    case mojom::CursorType::kSouthWestResize:
     case mojom::CursorType::kNorthEastSouthWestResize:
       return IDC_SIZENESW;
+    case mojom::CursorType::kNorthWestResize:
+    case mojom::CursorType::kSouthEastResize:
     case mojom::CursorType::kNorthWestSouthEastResize:
       return IDC_SIZENWSE;
     case mojom::CursorType::kMove:
@@ -66,7 +66,6 @@ const wchar_t* GetCursorId(gfx::NativeCursor native_cursor) {
     case mojom::CursorType::kProgress:
       return IDC_APPSTARTING;
     case mojom::CursorType::kNoDrop:
-      return IDC_NO;
     case mojom::CursorType::kNotAllowed:
       return IDC_NO;
     case mojom::CursorType::kColumnResize:
@@ -111,63 +110,66 @@ const wchar_t* GetCursorId(gfx::NativeCursor native_cursor) {
       return MAKEINTRESOURCE(IDC_COPYCUR);
     case mojom::CursorType::kAlias:
       return MAKEINTRESOURCE(IDC_ALIAS);
+    case mojom::CursorType::kDndCopy:
+    case mojom::CursorType::kDndLink:
+    case mojom::CursorType::kDndMove:
+    case mojom::CursorType::kDndNone:
     case mojom::CursorType::kContextMenu:
-    case mojom::CursorType::kCustom:
-    case mojom::CursorType::kNone:
       NOTIMPLEMENTED();
       return IDC_ARROW;
-    default:
+    case mojom::CursorType::kNone:
+    case mojom::CursorType::kCustom:
       NOTREACHED();
       return IDC_ARROW;
   }
+  NOTREACHED();
+  return IDC_ARROW;
 }
 
 }  // namespace
 
-std::unique_ptr<CursorLoader> CursorLoader::Create(bool use_platform_cursors) {
-  return std::make_unique<CursorLoaderWin>();
-}
-
-CursorLoaderWin::CursorLoaderWin() {
-}
+WinCursorFactory::WinCursorFactory() = default;
+
+WinCursorFactory::~WinCursorFactory() = default;
+
+base::Optional<PlatformCursor> WinCursorFactory::GetDefaultCursor(
+    mojom::CursorType type) {
+  if (!default_cursors_.count(type)) {
+    // Using a dark 1x1 bit bmp for the kNone cursor may still cause DWM to do
+    // composition work unnecessarily. Better to totally remove it from the
+    // screen. crbug.com/1069698
+    HCURSOR hcursor = nullptr;
+    if (type != mojom::CursorType::kNone) {
+      const wchar_t* id = GetCursorId(type);
+      hcursor = LoadCursor(nullptr, id);
+      // Try loading the cursor from the Chromium resources.
+      if (!hcursor)
+        hcursor = LoadCursorFromResourcesDataDLL(id);
+      if (!hcursor)
+        return base::nullopt;
+    }
+    default_cursors_[type] = base::MakeRefCounted<WinCursor>(hcursor);
+  }
 
-CursorLoaderWin::~CursorLoaderWin() {
+  auto cursor = default_cursors_[type];
+  return ToPlatformCursor(cursor.get());
 }
 
-void CursorLoaderWin::UnloadCursors() {
-  // NOTIMPLEMENTED();
+PlatformCursor WinCursorFactory::CreateImageCursor(mojom::CursorType type,
+                                                   const SkBitmap& bitmap,
+                                                   const gfx::Point& hotspot) {
+  auto cursor = base::MakeRefCounted<WinCursor>(
+      IconUtil::CreateCursorFromSkBitmap(bitmap, hotspot).release());
+  cursor->AddRef();
+  return ToPlatformCursor(cursor.get());
 }
 
-void CursorLoaderWin::SetPlatformCursor(gfx::NativeCursor* cursor) {
-  if (cursor->type() == mojom::CursorType::kCustom)
-    return;
-
-  // Using a dark 1x1 bit bmp kNone cursor may still cause DWM to do composition
-  // work unnecessarily. Better to totally remove it from the screen.
-  // crbug.com/1069698
-  if (cursor->type() == mojom::CursorType::kNone) {
-    cursor->SetPlatformCursor(nullptr);
-    return;
-  }
-
-  if (cursor->platform()) {
-    cursor->SetPlatformCursor(cursor->platform());
-  } else {
-    const wchar_t* cursor_id = GetCursorId(*cursor);
-    PlatformCursor platform_cursor = LoadCursor(nullptr, cursor_id);
-    if (!platform_cursor && !g_cursor_resource_module_name.Get().empty()) {
-      platform_cursor = LoadCursor(
-          GetModuleHandle(g_cursor_resource_module_name.Get().c_str()),
-          cursor_id);
-    }
-    cursor->SetPlatformCursor(platform_cursor);
-  }
+void WinCursorFactory::RefImageCursor(PlatformCursor cursor) {
+  ToWinCursor(cursor)->AddRef();
 }
 
-// static
-void CursorLoaderWin::SetCursorResourceModule(
-    const base::string16& module_name) {
-  g_cursor_resource_module_name.Get() = module_name;
+void WinCursorFactory::UnrefImageCursor(PlatformCursor cursor) {
+  ToWinCursor(cursor)->Release();
 }
 
 }  // namespace ui
diff --git a/chromium/ui/base/cursor/win/win_cursor_factory.h b/chromium/ui/base/cursor/win/win_cursor_factory.h
new file mode 100644
index 00000000000..21b6c53eb71
--- /dev/null
+++ b/chromium/ui/base/cursor/win/win_cursor_factory.h
@@ -0,0 +1,46 @@
+// Copyright 2021 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.
+
+#ifndef UI_BASE_CURSOR_WIN_WIN_CURSOR_FACTORY_H_
+#define UI_BASE_CURSOR_WIN_WIN_CURSOR_FACTORY_H_
+
+#include <map>
+
+#include "base/component_export.h"
+#include "base/memory/scoped_refptr.h"
+#include "ui/base/cursor/cursor_factory.h"
+#include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
+#include "ui/base/cursor/win/win_cursor.h"
+
+class SkBitmap;
+
+namespace gfx {
+class Point;
+}
+
+namespace ui {
+
+class COMPONENT_EXPORT(UI_BASE_CURSOR) WinCursorFactory : public CursorFactory {
+ public:
+  WinCursorFactory();
+  WinCursorFactory(const WinCursorFactory&) = delete;
+  WinCursorFactory& operator=(const WinCursorFactory&) = delete;
+  ~WinCursorFactory() override;
+
+  // CursorFactory:
+  base::Optional<PlatformCursor> GetDefaultCursor(
+      mojom::CursorType type) override;
+  PlatformCursor CreateImageCursor(mojom::CursorType type,
+                                   const SkBitmap& bitmap,
+                                   const gfx::Point& hotspot) override;
+  void RefImageCursor(PlatformCursor cursor) override;
+  void UnrefImageCursor(PlatformCursor cursor) override;
+
+ private:
+  std::map<mojom::CursorType, scoped_refptr<WinCursor>> default_cursors_;
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CURSOR_WIN_WIN_CURSOR_FACTORY_H_