BASELINE: Update Chromium to 85.0.4183.14085-based

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

32 files changed, 494 insertions, 882 deletions

diff --git a/chromium/ui/base/cursor/BUILD.gn b/chromium/ui/base/cursor/BUILD.gn
index e69e571c44b..f16386ecf4a 100644
--- a/chromium/ui/base/cursor/BUILD.gn
+++ b/chromium/ui/base/cursor/BUILD.gn
@@ -4,39 +4,123 @@
 
 import("//build/config/ui.gni")
 
-component("cursor") {
-  output_name = "ui_base_cursor"
-
+# This component was split from :cursor to allow Blink to depend on it without
+# bringing all of //ui/base/cursor.
+component("cursor_base") {
+  output_name = "ui_base_cursor_base"
   sources = [
     "cursor.cc",
     "cursor.h",
+    "cursor_factory.cc",
+    "cursor_factory.h",
     "cursor_size.h",
   ]
-
-  defines = [ "IS_UI_BASE_CURSOR_IMPL" ]
-
+  defines = [ "IS_UI_BASE_CURSOR_BASE_IMPL" ]
   public_deps = [
     "//base",
     "//skia",
     "//ui/base/cursor/mojom:cursor_type",
     "//ui/gfx/geometry",
   ]
-
   deps = [ "//ui/gfx:geometry_skia" ]
 
-  if (use_x11 && use_aura) {
-    sources += [ "cursor_x11.cc" ]
-
-    deps += [ "//ui/base/x" ]
+  if (is_win) {
+    sources += [ "cursor_win.cc" ]
   }
 
-  if (use_ozone) {
+  if (use_x11 || use_ozone) {
     sources += [ "cursor_ozone.cc" ]
+  }
+}
+
+source_set("theme_manager") {
+  sources = [
+    "cursor_theme_manager.cc",
+    "cursor_theme_manager.h",
+    "cursor_theme_manager_observer.h",
+  ]
+  deps = [ "//base" ]
+}
 
-    deps += [ "//ui/ozone:ozone_base" ]
+if (use_aura) {
+  component("cursor") {
+    output_name = "ui_base_cursor"
+    sources = [
+      "cursor_loader.h",
+      "cursor_lookup.cc",
+      "cursor_lookup.h",
+      "cursor_util.cc",
+      "cursor_util.h",
+      "cursors_aura.cc",
+      "cursors_aura.h",
+      "image_cursors.cc",
+      "image_cursors.h",
+    ]
+    defines = [ "IS_UI_BASE_CURSOR_IMPL" ]
+    public_deps = [
+      ":cursor_base",
+      "//base",
+      "//ui/base/cursor/mojom:cursor_type",
+      "//ui/display",
+      "//ui/gfx:native_widget_types",
+    ]
+    deps = [
+      "//skia",
+      "//ui/base",
+      "//ui/gfx",
+      "//ui/gfx:geometry_skia",
+      "//ui/gfx/geometry",
+      "//ui/resources:ui_resources_grd",
+    ]
+
+    if (is_win) {
+      sources += [
+        "cursor_loader_win.cc",
+        "cursor_loader_win.h",
+      ]
+      deps += [ "//ui/resources:ui_unscaled_resources_grd" ]
+    }
+
+    if (use_ozone) {
+      sources += [
+        "ozone/bitmap_cursor_factory_ozone.cc",
+        "ozone/bitmap_cursor_factory_ozone.h",
+      ]
+      public_deps += [
+        "//skia",
+        "//ui/gfx/geometry",
+      ]
+    }
+
+    if (use_x11 || use_ozone) {
+      sources += [
+        "cursor_loader_ozone.cc",
+        "cursor_loader_ozone.h",
+      ]
+    }
   }
+}
 
-  if (is_win) {
-    sources += [ "cursor_win.cc" ]
+source_set("unittests") {
+  testonly = true
+  sources = []
+  deps = [
+    "//skia",
+    "//testing/gtest",
+    "//ui/gfx/geometry",
+  ]
+
+  if (!is_ios) {
+    sources += [ "cursor_unittest.cc" ]
+    deps += [
+      ":cursor_base",
+      "//ui/base/cursor/mojom:cursor_type",
+      "//ui/gfx:geometry_skia",
+    ]
+  }
+
+  if (use_aura) {
+    sources += [ "cursor_util_unittest.cc" ]
+    deps += [ ":cursor" ]
   }
 }
diff --git a/chromium/ui/base/cursor/DEPS b/chromium/ui/base/cursor/DEPS
deleted file mode 100644
index de08167e272..00000000000
--- a/chromium/ui/base/cursor/DEPS
+++ /dev/null
@@ -1,3 +0,0 @@
-include_rules = [
-  "+ui/ozone/public",
-]
diff --git a/chromium/ui/base/cursor/cursor.h b/chromium/ui/base/cursor/cursor.h
index 095798ce964..835027a9ac4 100644
--- a/chromium/ui/base/cursor/cursor.h
+++ b/chromium/ui/base/cursor/cursor.h
@@ -21,14 +21,12 @@ namespace ui {
 
 #if defined(OS_WIN)
 typedef ::HCURSOR PlatformCursor;
-#elif defined(USE_X11)
-typedef unsigned long PlatformCursor;
 #else
 typedef void* PlatformCursor;
 #endif
 
 // Ref-counted cursor that supports both default and custom cursors.
-class COMPONENT_EXPORT(UI_BASE_CURSOR) Cursor {
+class COMPONENT_EXPORT(UI_BASE_CURSOR_BASE) Cursor {
  public:
   Cursor();
 
diff --git a/chromium/ui/base/cursor/cursor_factory.cc b/chromium/ui/base/cursor/cursor_factory.cc
new file mode 100644
index 00000000000..43645a5d446
--- /dev/null
+++ b/chromium/ui/base/cursor/cursor_factory.cc
@@ -0,0 +1,68 @@
+// 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.
+
+#include "ui/base/cursor/cursor_factory.h"
+
+#include <ostream>
+
+#include "base/check.h"
+#include "base/check_op.h"
+#include "base/notreached.h"
+
+namespace ui {
+
+namespace {
+
+CursorFactory* g_instance = nullptr;
+
+}  // namespace
+
+CursorFactory::CursorFactory() {
+  DCHECK(!g_instance) << "There should only be a single CursorFactory.";
+  g_instance = this;
+}
+
+CursorFactory::~CursorFactory() {
+  DCHECK_EQ(g_instance, this);
+  g_instance = nullptr;
+}
+
+CursorFactory* CursorFactory::GetInstance() {
+  DCHECK(g_instance);
+  return g_instance;
+}
+
+base::Optional<PlatformCursor> CursorFactory::GetDefaultCursor(
+    mojom::CursorType type) {
+  NOTIMPLEMENTED();
+  return base::nullopt;
+}
+
+PlatformCursor CursorFactory::CreateImageCursor(const SkBitmap& bitmap,
+                                                const gfx::Point& hotspot) {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+PlatformCursor CursorFactory::CreateAnimatedCursor(
+    const std::vector<SkBitmap>& bitmaps,
+    const gfx::Point& hotspot,
+    int frame_delay_ms) {
+  NOTIMPLEMENTED();
+  return 0;
+}
+
+void CursorFactory::RefImageCursor(PlatformCursor cursor) {
+  NOTIMPLEMENTED();
+}
+
+void CursorFactory::UnrefImageCursor(PlatformCursor cursor) {
+  NOTIMPLEMENTED();
+}
+
+void CursorFactory::ObserveThemeChanges() {
+  NOTIMPLEMENTED();
+}
+
+}  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_factory.h b/chromium/ui/base/cursor/cursor_factory.h
new file mode 100644
index 00000000000..f038a422819
--- /dev/null
+++ b/chromium/ui/base/cursor/cursor_factory.h
@@ -0,0 +1,67 @@
+// 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_FACTORY_H_
+#define UI_BASE_CURSOR_CURSOR_FACTORY_H_
+
+#include <vector>
+
+#include "base/component_export.h"
+#include "base/optional.h"
+#include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
+
+class SkBitmap;
+
+namespace gfx {
+class Point;
+}
+
+namespace ui {
+using PlatformCursor = void*;
+
+class COMPONENT_EXPORT(UI_BASE_CURSOR_BASE) CursorFactory {
+ public:
+  CursorFactory();
+  virtual ~CursorFactory();
+
+  // Returns the thread-local instance.
+  static CursorFactory* GetInstance();
+
+  // Return the default cursor of the specified type. The types are listed in
+  // ui/base/cursor/cursor.h. Default cursors are managed by the implementation
+  // and must live indefinitely; there's no way to know when to free them.
+  // nullptr may be a valid value for the hidden cursor. When a default cursor
+  // is not available, base::nullopt is returned.
+  virtual base::Optional<PlatformCursor> GetDefaultCursor(
+      mojom::CursorType type);
+
+  // Return a image cursor from the specified image & hotspot. Image cursors
+  // are referenced counted and have an initial refcount of 1. Therefore, each
+  // CreateImageCursor call must be matched with a call to UnrefImageCursor.
+  virtual PlatformCursor CreateImageCursor(const SkBitmap& bitmap,
+                                           const gfx::Point& hotspot);
+
+  // Return a animated cursor from the specified image & hotspot. Animated
+  // cursors are referenced counted and have an initial refcount of 1.
+  // Therefore, each CreateAnimatedCursor call must be matched with a call to
+  // UnrefImageCursor.
+  virtual PlatformCursor CreateAnimatedCursor(
+      const std::vector<SkBitmap>& bitmaps,
+      const gfx::Point& hotspot,
+      int frame_delay_ms);
+
+  // Increment platform image cursor refcount.
+  virtual void RefImageCursor(PlatformCursor cursor);
+
+  // Decrement platform image cursor refcount.
+  virtual void UnrefImageCursor(PlatformCursor cursor);
+
+  // Called after CursorThemeManager is initialized, to be able to track
+  // cursor theme and size changes.
+  virtual void ObserveThemeChanges();
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CURSOR_CURSOR_FACTORY_H_
diff --git a/chromium/ui/base/cursor/cursor_loader.h b/chromium/ui/base/cursor/cursor_loader.h
index 95141089ffe..2553c54e488 100644
--- a/chromium/ui/base/cursor/cursor_loader.h
+++ b/chromium/ui/base/cursor/cursor_loader.h
@@ -5,18 +5,19 @@
 #ifndef UI_BASE_CURSOR_CURSOR_LOADER_H_
 #define UI_BASE_CURSOR_CURSOR_LOADER_H_
 
-#include "base/logging.h"
+#include "base/component_export.h"
 #include "base/macros.h"
-#include "base/strings/string16.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
-#include "ui/base/ui_base_export.h"
 #include "ui/display/display.h"
-#include "ui/gfx/geometry/point.h"
 #include "ui/gfx/native_widget_types.h"
 
+namespace gfx {
+class Point;
+}
+
 namespace ui {
 
-class UI_BASE_EXPORT CursorLoader {
+class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoader {
  public:
   CursorLoader() : scale_(1.f), rotation_(display::Display::ROTATE_0) {}
   virtual ~CursorLoader() {}
diff --git a/chromium/ui/base/cursor/cursor_loader_ozone.cc b/chromium/ui/base/cursor/cursor_loader_ozone.cc
index 8668095578e..6df16b5f1e7 100644
--- a/chromium/ui/base/cursor/cursor_loader_ozone.cc
+++ b/chromium/ui/base/cursor/cursor_loader_ozone.cc
@@ -6,15 +6,16 @@
 
 #include <vector>
 
-#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/ozone/public/cursor_factory_ozone.h"
 
 namespace ui {
 
 CursorLoaderOzone::CursorLoaderOzone() {
-  factory_ = CursorFactoryOzone::GetInstance();
+  factory_ = CursorFactory::GetInstance();
 }
 
 CursorLoaderOzone::~CursorLoaderOzone() {
@@ -29,7 +30,7 @@ void CursorLoaderOzone::LoadImageCursor(mojom::CursorType id,
 
   GetImageCursorBitmap(resource_id, scale(), rotation(), &hotspot, &bitmap);
 
-  image_cursors_[id] = factory_->CreateImageCursor(bitmap, hotspot, scale());
+  image_cursors_[id] = factory_->CreateImageCursor(bitmap, hotspot);
 }
 
 void CursorLoaderOzone::LoadAnimatedCursor(mojom::CursorType id,
@@ -43,7 +44,7 @@ void CursorLoaderOzone::LoadAnimatedCursor(mojom::CursorType id,
       resource_id, scale(), rotation(), &hotspot, &bitmaps);
 
   image_cursors_[id] =
-      factory_->CreateAnimatedCursor(bitmaps, hotspot, frame_delay_ms, scale());
+      factory_->CreateAnimatedCursor(bitmaps, hotspot, frame_delay_ms);
 }
 
 void CursorLoaderOzone::UnloadAll() {
@@ -53,22 +54,48 @@ void CursorLoaderOzone::UnloadAll() {
 }
 
 void CursorLoaderOzone::SetPlatformCursor(gfx::NativeCursor* cursor) {
-  mojom::CursorType native_type = cursor->type();
-  PlatformCursor platform;
-
-  if (image_cursors_.count(native_type)) {
-    // An image cursor is loaded for this type.
-    platform = image_cursors_[native_type];
-  } else if (native_type == mojom::CursorType::kCustom) {
-    // The platform cursor was already set via WebCursor::GetPlatformCursor.
-    platform = cursor->platform();
-  } else {
-    // Use default cursor of this type.
-    platform = factory_->GetDefaultCursor(native_type);
-  }
+  DCHECK(cursor);
 
+  // The platform cursor was already set via WebCursor::GetPlatformCursor.
+  if (cursor->type() == mojom::CursorType::kCustom)
+    return;
   cursor->set_image_scale_factor(scale());
-  cursor->SetPlatformCursor(platform);
+  cursor->SetPlatformCursor(CursorFromType(cursor->type()));
+}
+
+PlatformCursor CursorLoaderOzone::CursorFromType(mojom::CursorType type) {
+  // An image cursor is loaded for this type.
+  if (image_cursors_.count(type))
+    return image_cursors_[type];
+
+  // Check if there's a default platform cursor available.
+  base::Optional<PlatformCursor> default_cursor =
+      factory_->GetDefaultCursor(type);
+  if (default_cursor)
+    return *default_cursor;
+
+  // Loads the default Aura cursor bitmap for the cursor type. Falls back on
+  // pointer cursor if this fails.
+  PlatformCursor platform = CreateFallbackCursor(type);
+  if (!platform && type != mojom::CursorType::kPointer) {
+    platform = CursorFromType(mojom::CursorType::kPointer);
+    factory_->RefImageCursor(platform);
+    image_cursors_[type] = platform;
+  }
+  DCHECK(platform) << "Failed to load a fallback bitmap for cursor " << type;
+  return platform;
+}
+
+// Gets default Aura cursor bitmap/hotspot and creates a PlatformCursor with it.
+PlatformCursor CursorLoaderOzone::CreateFallbackCursor(mojom::CursorType type) {
+  int resource_id;
+  gfx::Point point;
+  if (ui::GetCursorDataFor(ui::CursorSize::kNormal, type, scale(), &resource_id,
+                           &point)) {
+    LoadImageCursor(type, resource_id, point);
+    return image_cursors_[type];
+  }
+  return nullptr;
 }
 
 CursorLoader* CursorLoader::Create() {
diff --git a/chromium/ui/base/cursor/cursor_loader_ozone.h b/chromium/ui/base/cursor/cursor_loader_ozone.h
index 9d561727761..ccd23a3c9e0 100644
--- a/chromium/ui/base/cursor/cursor_loader_ozone.h
+++ b/chromium/ui/base/cursor/cursor_loader_ozone.h
@@ -7,19 +7,17 @@
 
 #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 ui {
+class CursorFactory;
 
-class CursorFactoryOzone;
-
-class UI_BASE_EXPORT CursorLoaderOzone : public CursorLoader {
+class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoaderOzone : public CursorLoader {
  public:
-  // CursorLoaderOzone will use CursorFactoryOzone corresponding to the thread
-  // it was constructed on.
   CursorLoaderOzone();
   ~CursorLoaderOzone() override;
 
@@ -35,9 +33,12 @@ class UI_BASE_EXPORT CursorLoaderOzone : public CursorLoader {
   void SetPlatformCursor(gfx::NativeCursor* cursor) override;
 
  private:
+  PlatformCursor CursorFromType(mojom::CursorType type);
+  PlatformCursor CreateFallbackCursor(mojom::CursorType type);
+
   // Pointers are owned by ResourceBundle and must not be freed here.
   std::map<mojom::CursorType, PlatformCursor> image_cursors_;
-  CursorFactoryOzone* factory_ = nullptr;
+  CursorFactory* factory_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(CursorLoaderOzone);
 };
diff --git a/chromium/ui/base/cursor/cursor_loader_win.cc b/chromium/ui/base/cursor/cursor_loader_win.cc
index d981eb79cda..735568dddc0 100644
--- a/chromium/ui/base/cursor/cursor_loader_win.cc
+++ b/chromium/ui/base/cursor/cursor_loader_win.cc
@@ -7,7 +7,7 @@
 #include <windows.h>
 
 #include "base/lazy_instance.h"
-#include "base/strings/string16.h"
+#include "base/notreached.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
 #include "ui/resources/grit/ui_unscaled_resources.h"
diff --git a/chromium/ui/base/cursor/cursor_loader_win.h b/chromium/ui/base/cursor/cursor_loader_win.h
index f17ca9f965b..bf3ec63c961 100644
--- a/chromium/ui/base/cursor/cursor_loader_win.h
+++ b/chromium/ui/base/cursor/cursor_loader_win.h
@@ -5,13 +5,14 @@
 #ifndef UI_BASE_CURSOR_CURSOR_LOADER_WIN_H_
 #define UI_BASE_CURSOR_CURSOR_LOADER_WIN_H_
 
-#include "base/compiler_specific.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 UI_BASE_EXPORT CursorLoaderWin : public CursorLoader {
+class COMPONENT_EXPORT(UI_BASE_CURSOR) CursorLoaderWin : public CursorLoader {
  public:
   CursorLoaderWin();
   ~CursorLoaderWin() override;
diff --git a/chromium/ui/base/cursor/cursor_loader_x11.cc b/chromium/ui/base/cursor/cursor_loader_x11.cc
deleted file mode 100644
index e0b52555d62..00000000000
--- a/chromium/ui/base/cursor/cursor_loader_x11.cc
+++ /dev/null
@@ -1,310 +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_loader_x11.h"
-
-#include <float.h>
-
-#include "base/check.h"
-#include "base/notreached.h"
-#include "build/build_config.h"
-#include "skia/ext/image_operations.h"
-#include "ui/base/cursor/cursor.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/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 ui {
-
-namespace {
-
-// Load a cursor with a list of css names or shapes in order of decreasing
-// priority.
-::Cursor LoadFontCursor() {
-  return x11::None;
-}
-
-template <typename... Ts>
-::Cursor LoadFontCursor(int shape, Ts... ts);
-
-template <typename... Ts>
-::Cursor LoadFontCursor(const char* name, Ts... ts) {
-  ::Cursor cursor = XcursorLibraryLoadCursor(gfx::GetXDisplay(), name);
-  if (cursor != x11::None)
-    return cursor;
-  return LoadFontCursor(ts...);
-}
-
-template <typename... Ts>
-::Cursor LoadFontCursor(int shape, Ts... ts) {
-  ::Cursor cursor = XCreateFontCursor(gfx::GetXDisplay(), shape);
-  if (cursor != x11::None)
-    return cursor;
-  return LoadFontCursor(ts...);
-}
-
-::Cursor LoadFontCursorForCursorType(mojom::CursorType id) {
-  switch (id) {
-    case mojom::CursorType::kMiddlePanning:
-      return LoadFontCursor("all-scroll", XC_fleur);
-    case mojom::CursorType::kMiddlePanningVertical:
-      return LoadFontCursor("v-scroll");
-    case mojom::CursorType::kMiddlePanningHorizontal:
-      return LoadFontCursor("h-scroll");
-    case mojom::CursorType::kNone:
-      return LoadFontCursor("none");
-    case mojom::CursorType::kGrab:
-      return LoadFontCursor("openhand", "grab");
-    case mojom::CursorType::kGrabbing:
-      return LoadFontCursor("closedhand", "grabbing", XC_hand2);
-    case mojom::CursorType::kNull:
-    case mojom::CursorType::kPointer:
-      return LoadFontCursor("left_ptr", XC_left_ptr);
-    case mojom::CursorType::kMove:
-      return LoadFontCursor("all-scroll", XC_fleur);
-    case mojom::CursorType::kCross:
-      return LoadFontCursor("crosshair", XC_cross);
-    case mojom::CursorType::kHand:
-      return LoadFontCursor("pointer", "hand", XC_hand2);
-    case mojom::CursorType::kIBeam:
-      return LoadFontCursor("text", XC_xterm);
-    case mojom::CursorType::kProgress:
-      return LoadFontCursor("progress", "left_ptr_watch", XC_watch);
-    case mojom::CursorType::kWait:
-      return LoadFontCursor("wait", XC_watch);
-    case mojom::CursorType::kHelp:
-      return LoadFontCursor("help");
-    case mojom::CursorType::kEastResize:
-    case mojom::CursorType::kEastPanning:
-      return LoadFontCursor("e-resize", XC_right_side);
-    case mojom::CursorType::kNorthResize:
-    case mojom::CursorType::kNorthPanning:
-      return LoadFontCursor("n-resize", XC_top_side);
-    case mojom::CursorType::kNorthEastResize:
-    case mojom::CursorType::kNorthEastPanning:
-      return LoadFontCursor("ne-resize", XC_top_right_corner);
-    case mojom::CursorType::kNorthWestResize:
-    case mojom::CursorType::kNorthWestPanning:
-      return LoadFontCursor("nw-resize", XC_top_left_corner);
-    case mojom::CursorType::kSouthResize:
-    case mojom::CursorType::kSouthPanning:
-      return LoadFontCursor("s-resize", XC_bottom_side);
-    case mojom::CursorType::kSouthEastResize:
-    case mojom::CursorType::kSouthEastPanning:
-      return LoadFontCursor("se-resize", XC_bottom_right_corner);
-    case mojom::CursorType::kSouthWestResize:
-    case mojom::CursorType::kSouthWestPanning:
-      return LoadFontCursor("sw-resize", XC_bottom_left_corner);
-    case mojom::CursorType::kWestResize:
-    case mojom::CursorType::kWestPanning:
-      return LoadFontCursor("w-resize", XC_right_side);
-    case mojom::CursorType::kNorthSouthResize:
-      return LoadFontCursor(XC_sb_v_double_arrow, "ns-resize");
-    case mojom::CursorType::kEastWestResize:
-      return LoadFontCursor(XC_sb_h_double_arrow, "ew-resize");
-    case mojom::CursorType::kColumnResize:
-      return LoadFontCursor("col-resize", XC_sb_h_double_arrow);
-    case mojom::CursorType::kRowResize:
-      return LoadFontCursor("row-resize", XC_sb_v_double_arrow);
-    case mojom::CursorType::kNorthEastSouthWestResize:
-      return LoadFontCursor("size_bdiag", "nesw-resize", "fd_double_arrow");
-    case mojom::CursorType::kNorthWestSouthEastResize:
-      return LoadFontCursor("size_fdiag", "nwse-resize", "bd_double_arrow");
-    case mojom::CursorType::kVerticalText:
-      return LoadFontCursor("vertical-text");
-    case mojom::CursorType::kZoomIn:
-      return LoadFontCursor("zoom-in");
-    case mojom::CursorType::kZoomOut:
-      return LoadFontCursor("zoom-out");
-    case mojom::CursorType::kCell:
-      return LoadFontCursor("cell", XC_plus);
-    case mojom::CursorType::kContextMenu:
-      return LoadFontCursor("context-menu");
-    case mojom::CursorType::kAlias:
-      return LoadFontCursor("alias");
-    case mojom::CursorType::kNoDrop:
-      return LoadFontCursor("no-drop");
-    case mojom::CursorType::kCopy:
-      return LoadFontCursor("copy");
-    case mojom::CursorType::kNotAllowed:
-      return LoadFontCursor("not-allowed", "crossed_circle");
-    case mojom::CursorType::kDndNone:
-      return LoadFontCursor("dnd-none", XC_hand2);
-    case mojom::CursorType::kDndMove:
-      return LoadFontCursor("dnd-move", XC_hand2);
-    case mojom::CursorType::kDndCopy:
-      return LoadFontCursor("dnd-copy", XC_hand2);
-    case mojom::CursorType::kDndLink:
-      return LoadFontCursor("dnd-link", XC_hand2);
-    case mojom::CursorType::kCustom:
-      NOTREACHED();
-      return LoadFontCursor();
-  }
-  NOTREACHED() << "Case not handled for " << static_cast<int>(id);
-  return LoadFontCursor();
-}
-
-}  // namespace
-
-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()
-    : display_(gfx::GetXDisplay()),
-      invisible_cursor_(CreateInvisibleCursor(), gfx::GetXDisplay()) {
-  auto* cursor_theme_manager = CursorThemeManagerLinux::GetInstance();
-  if (cursor_theme_manager)
-    cursor_theme_observer_.Add(cursor_theme_manager);
-}
-
-CursorLoaderX11::~CursorLoaderX11() {
-  UnloadAll();
-}
-
-void CursorLoaderX11::LoadImageCursor(mojom::CursorType 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);
-  image_cursors_[id] =
-      std::make_unique<ImageCursor>(x_image, scale(), rotation());
-}
-
-void CursorLoaderX11::LoadAnimatedCursor(mojom::CursorType 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);
-
-  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() {
-  image_cursors_.clear();
-
-  // Free animated cursors and images.
-  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);
-
-  if (*cursor == mojom::CursorType::kNone) {
-    cursor->SetPlatformCursor(invisible_cursor_.get());
-    return;
-  }
-
-  if (*cursor == mojom::CursorType::kCustom)
-    return;
-
-  cursor->set_image_scale_factor(scale());
-  cursor->SetPlatformCursor(CursorFromId(cursor->type()));
-}
-
-const XcursorImage* CursorLoaderX11::GetXcursorImageForTest(
-    mojom::CursorType id) {
-  return test::GetCachedXcursorImage(image_cursors_[id]->cursor);
-}
-
-void CursorLoaderX11::OnCursorThemeNameChanged(
-    const std::string& cursor_theme_name) {
-  XcursorSetTheme(display_, cursor_theme_name.c_str());
-  ClearThemeCursors();
-}
-
-void CursorLoaderX11::OnCursorThemeSizeChanged(int cursor_theme_size) {
-  XcursorSetDefaultSize(display_, cursor_theme_size);
-  ClearThemeCursors();
-}
-
-bool CursorLoaderX11::IsImageCursor(gfx::NativeCursor native_cursor) {
-  mojom::CursorType type = native_cursor.type();
-  return image_cursors_.count(type) || animated_cursors_.count(type);
-}
-
-::Cursor CursorLoaderX11::CursorFromId(mojom::CursorType id) {
-  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 = LoadFontCursorForCursorType(id);
-  if (cursor != x11::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::CursorSize::kNormal, 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;
-}
-
-void CursorLoaderX11::ClearThemeCursors() {
-  font_cursors_.clear();
-  image_cursors_.clear();
-}
-
-}  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_loader_x11.h b/chromium/ui/base/cursor/cursor_loader_x11.h
deleted file mode 100644
index 26870d09e03..00000000000
--- a/chromium/ui/base/cursor/cursor_loader_x11.h
+++ /dev/null
@@ -1,93 +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_X11_H_
-#define UI_BASE_CURSOR_CURSOR_LOADER_X11_H_
-
-#include <map>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/scoped_observer.h"
-#include "ui/base/cursor/cursor.h"
-#include "ui/base/cursor/cursor_loader.h"
-#include "ui/base/cursor/cursor_theme_manager_linux.h"
-#include "ui/base/cursor/cursor_theme_manager_linux_observer.h"
-#include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
-#include "ui/base/ui_base_export.h"
-#include "ui/base/x/x11_util.h"
-#include "ui/gfx/x/x11.h"
-
-namespace ui {
-
-class UI_BASE_EXPORT CursorLoaderX11 : public CursorLoader,
-                                       public CursorThemeManagerLinuxObserver {
- public:
-  CursorLoaderX11();
-  ~CursorLoaderX11() override;
-
-  // Overridden from CursorLoader:
-  void LoadImageCursor(mojom::CursorType id,
-                       int resource_id,
-                       const gfx::Point& hot) override;
-  void LoadAnimatedCursor(mojom::CursorType id,
-                          int resource_id,
-                          const gfx::Point& hot,
-                          int frame_delay_ms) override;
-  void UnloadAll() override;
-  void SetPlatformCursor(gfx::NativeCursor* cursor) override;
-
-  const XcursorImage* GetXcursorImageForTest(mojom::CursorType id);
-
- protected:
-  // CursorThemeManagerLinux:
-  void OnCursorThemeNameChanged(const std::string& cursor_theme_name) override;
-  void OnCursorThemeSizeChanged(int cursor_theme_size) override;
-
- private:
-  struct ImageCursor {
-    ImageCursor(XcursorImage* x_image,
-                float scale,
-                display::Display::Rotation rotation);
-    ~ImageCursor();
-
-    ::Cursor cursor;
-    float scale;
-    display::Display::Rotation rotation;
-  };
-
-  // Returns true if we have an image resource loaded for the |native_cursor|.
-  bool IsImageCursor(gfx::NativeCursor native_cursor);
-
-  // Loads a new cursor corresponding to |id|.
-  ::Cursor CursorFromId(mojom::CursorType id);
-
-  void ClearThemeCursors();
-
-  XDisplay* display_;
-
-  // A map from a cursor native type to X cursor.
-  std::map<mojom::CursorType, ::Cursor> font_cursors_;
-
-  // A map to hold all image cursors. It maps the cursor ID to the X Cursor, the
-  // display's scale factor, and the display's rotation.
-  std::map<mojom::CursorType, std::unique_ptr<ImageCursor>> image_cursors_;
-
-  // A map to hold all animated cursors. It maps the cursor ID to the pair of
-  // the X Cursor and the corresponding XcursorImages. We need a pointer to the
-  // images so that we can free them on destruction.
-  std::map<mojom::CursorType, std::pair<::Cursor, XcursorImages*>>
-      animated_cursors_;
-
-  const XScopedCursor invisible_cursor_;
-
-  ScopedObserver<CursorThemeManagerLinux, CursorThemeManagerLinuxObserver>
-      cursor_theme_observer_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(CursorLoaderX11);
-};
-
-}  // namespace ui
-
-#endif  // UI_BASE_CURSOR_CURSOR_LOADER_X11_H_
diff --git a/chromium/ui/base/cursor/cursor_lookup.h b/chromium/ui/base/cursor/cursor_lookup.h
index 47aefe22f6c..82f908422a1 100644
--- a/chromium/ui/base/cursor/cursor_lookup.h
+++ b/chromium/ui/base/cursor/cursor_lookup.h
@@ -5,7 +5,7 @@
 #ifndef UI_BASE_CURSOR_CURSOR_LOOKUP_H_
 #define UI_BASE_CURSOR_CURSOR_LOOKUP_H_
 
-#include "ui/base/ui_base_export.h"
+#include "base/component_export.h"
 
 class SkBitmap;
 
@@ -16,9 +16,11 @@ class Point;
 namespace ui {
 class Cursor;
 
-SkBitmap UI_BASE_EXPORT GetCursorBitmap(const Cursor& cursor);
+COMPONENT_EXPORT(UI_BASE_CURSOR)
+SkBitmap GetCursorBitmap(const Cursor& cursor);
 
-gfx::Point UI_BASE_EXPORT GetCursorHotspot(const Cursor& cursor);
+COMPONENT_EXPORT(UI_BASE_CURSOR)
+gfx::Point GetCursorHotspot(const Cursor& cursor);
 
 }  // namespace ui
 
diff --git a/chromium/ui/base/cursor/cursor_ozone.cc b/chromium/ui/base/cursor/cursor_ozone.cc
index c4ef8c4d45e..b41f4ca3b67 100644
--- a/chromium/ui/base/cursor/cursor_ozone.cc
+++ b/chromium/ui/base/cursor/cursor_ozone.cc
@@ -4,18 +4,18 @@
 
 #include "ui/base/cursor/cursor.h"
 
-#include "ui/ozone/public/cursor_factory_ozone.h"
+#include "ui/base/cursor/cursor_factory.h"
 
 namespace ui {
 
 void Cursor::RefCustomCursor() {
   if (platform_cursor_)
-    CursorFactoryOzone::GetInstance()->RefImageCursor(platform_cursor_);
+    CursorFactory::GetInstance()->RefImageCursor(platform_cursor_);
 }
 
 void Cursor::UnrefCustomCursor() {
   if (platform_cursor_)
-    CursorFactoryOzone::GetInstance()->UnrefImageCursor(platform_cursor_);
+    CursorFactory::GetInstance()->UnrefImageCursor(platform_cursor_);
 }
 
 }  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_theme_manager.cc b/chromium/ui/base/cursor/cursor_theme_manager.cc
new file mode 100644
index 00000000000..665725a1c27
--- /dev/null
+++ b/chromium/ui/base/cursor/cursor_theme_manager.cc
@@ -0,0 +1,47 @@
+// Copyright 2019 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_theme_manager.h"
+
+#include "base/check.h"
+#include "base/check_op.h"
+
+namespace ui {
+
+namespace {
+
+CursorThemeManager* g_instance = nullptr;
+
+}
+
+CursorThemeManager::~CursorThemeManager() {
+  DCHECK_EQ(g_instance, this);
+  g_instance = nullptr;
+}
+
+// static
+CursorThemeManager* CursorThemeManager::GetInstance() {
+  return g_instance;
+}
+
+void CursorThemeManager::AddObserver(CursorThemeManagerObserver* observer) {
+  cursor_theme_observers_.AddObserver(observer);
+  std::string name = GetCursorThemeName();
+  if (!name.empty())
+    observer->OnCursorThemeNameChanged(name);
+  int size = GetCursorThemeSize();
+  if (size)
+    observer->OnCursorThemeSizeChanged(size);
+}
+
+void CursorThemeManager::RemoveObserver(CursorThemeManagerObserver* observer) {
+  cursor_theme_observers_.RemoveObserver(observer);
+}
+
+CursorThemeManager::CursorThemeManager() {
+  DCHECK(!g_instance);
+  g_instance = this;
+}
+
+}  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_theme_manager.h b/chromium/ui/base/cursor/cursor_theme_manager.h
new file mode 100644
index 00000000000..a6d09f04945
--- /dev/null
+++ b/chromium/ui/base/cursor/cursor_theme_manager.h
@@ -0,0 +1,46 @@
+// Copyright 2019 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_THEME_MANAGER_H_
+#define UI_BASE_CURSOR_CURSOR_THEME_MANAGER_H_
+
+#include <string>
+
+#include "base/observer_list.h"
+#include "ui/base/cursor/cursor_theme_manager_observer.h"
+
+namespace ui {
+
+class CursorThemeManager {
+ public:
+  CursorThemeManager(const CursorThemeManager&) = delete;
+  CursorThemeManager& operator=(const CursorThemeManager&) = delete;
+  virtual ~CursorThemeManager();
+
+  static CursorThemeManager* GetInstance();
+
+  // Adds |observer| and makes initial OnCursorThemNameChanged() and/or
+  // OnCursorThemeSizeChanged() calls if the respective settings were set.
+  void AddObserver(CursorThemeManagerObserver* observer);
+
+  void RemoveObserver(CursorThemeManagerObserver* observer);
+
+ protected:
+  CursorThemeManager();
+
+  const base::ObserverList<CursorThemeManagerObserver>&
+  cursor_theme_observers() {
+    return cursor_theme_observers_;
+  }
+
+  virtual std::string GetCursorThemeName() = 0;
+  virtual int GetCursorThemeSize() = 0;
+
+ private:
+  base::ObserverList<CursorThemeManagerObserver> cursor_theme_observers_;
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_CURSOR_CURSOR_THEME_MANAGER_H_
diff --git a/chromium/ui/base/cursor/cursor_theme_manager_linux.cc b/chromium/ui/base/cursor/cursor_theme_manager_linux.cc
deleted file mode 100644
index f825b745f5d..00000000000
--- a/chromium/ui/base/cursor/cursor_theme_manager_linux.cc
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2019 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_theme_manager_linux.h"
-
-namespace ui {
-
-// static
-CursorThemeManagerLinux* CursorThemeManagerLinux::instance_ = nullptr;
-
-// static
-void CursorThemeManagerLinux::SetInstance(CursorThemeManagerLinux* instance) {
-  instance_ = instance;
-}
-
-// static
-CursorThemeManagerLinux* CursorThemeManagerLinux::GetInstance() {
-  return instance_;
-}
-
-CursorThemeManagerLinux::CursorThemeManagerLinux() = default;
-
-CursorThemeManagerLinux::~CursorThemeManagerLinux() = default;
-
-void CursorThemeManagerLinux::AddObserver(
-    CursorThemeManagerLinuxObserver* observer) {
-  cursor_theme_observers_.AddObserver(observer);
-  std::string name = GetCursorThemeName();
-  if (!name.empty())
-    observer->OnCursorThemeNameChanged(name);
-  int size = GetCursorThemeSize();
-  if (size)
-    observer->OnCursorThemeSizeChanged(size);
-}
-
-void CursorThemeManagerLinux::RemoveObserver(
-    CursorThemeManagerLinuxObserver* observer) {
-  cursor_theme_observers_.RemoveObserver(observer);
-}
-
-}  // namespace ui
diff --git a/chromium/ui/base/cursor/cursor_theme_manager_linux.h b/chromium/ui/base/cursor/cursor_theme_manager_linux.h
deleted file mode 100644
index 464d397cec5..00000000000
--- a/chromium/ui/base/cursor/cursor_theme_manager_linux.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019 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_THEME_MANAGER_LINUX_H_
-#define UI_BASE_CURSOR_CURSOR_THEME_MANAGER_LINUX_H_
-
-#include <string>
-
-#include "base/macros.h"
-#include "base/observer_list.h"
-#include "ui/base/cursor/cursor_theme_manager_linux_observer.h"
-#include "ui/base/ui_base_export.h"
-
-namespace ui {
-
-class UI_BASE_EXPORT CursorThemeManagerLinux {
- public:
-  virtual ~CursorThemeManagerLinux();
-
-  static void SetInstance(CursorThemeManagerLinux* instance);
-
-  static CursorThemeManagerLinux* GetInstance();
-
-  // Adds |observer| and makes initial OnCursorThemNameChanged() and/or
-  // OnCursorThemeSizeChanged() calls if the respective settings were set.
-  void AddObserver(CursorThemeManagerLinuxObserver* observer);
-
-  void RemoveObserver(CursorThemeManagerLinuxObserver* observer);
-
- protected:
-  CursorThemeManagerLinux();
-
-  const base::ObserverList<CursorThemeManagerLinuxObserver>&
-  cursor_theme_observers() {
-    return cursor_theme_observers_;
-  }
-
-  virtual std::string GetCursorThemeName() = 0;
-  virtual int GetCursorThemeSize() = 0;
-
- private:
-  static CursorThemeManagerLinux* instance_;
-
-  base::ObserverList<CursorThemeManagerLinuxObserver> cursor_theme_observers_;
-
-  DISALLOW_COPY_AND_ASSIGN(CursorThemeManagerLinux);
-};
-
-}  // namespace ui
-
-#endif  // UI_BASE_CURSOR_CURSOR_THEME_MANAGER_LINUX_H_
diff --git a/chromium/ui/base/cursor/cursor_theme_manager_linux_observer.h b/chromium/ui/base/cursor/cursor_theme_manager_observer.h
index 73a3b42f343..028a8bb7dfe 100644
--- a/chromium/ui/base/cursor/cursor_theme_manager_linux_observer.h
+++ b/chromium/ui/base/cursor/cursor_theme_manager_observer.h
@@ -2,18 +2,16 @@
 // 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_THEME_MANAGER_LINUX_OBSERVER_H_
-#define UI_BASE_CURSOR_CURSOR_THEME_MANAGER_LINUX_OBSERVER_H_
+#ifndef UI_BASE_CURSOR_CURSOR_THEME_MANAGER_OBSERVER_H_
+#define UI_BASE_CURSOR_CURSOR_THEME_MANAGER_OBSERVER_H_
 
 #include <string>
 
 #include "base/observer_list_types.h"
-#include "ui/base/ui_base_export.h"
 
 namespace ui {
 
-class UI_BASE_EXPORT CursorThemeManagerLinuxObserver
-    : public base::CheckedObserver {
+class CursorThemeManagerObserver : public base::CheckedObserver {
  public:
   // |cursor_theme_name| will be nonempty.
   virtual void OnCursorThemeNameChanged(
@@ -23,9 +21,9 @@ class UI_BASE_EXPORT CursorThemeManagerLinuxObserver
   virtual void OnCursorThemeSizeChanged(int cursor_theme_size) = 0;
 
  protected:
-  ~CursorThemeManagerLinuxObserver() override = default;
+  ~CursorThemeManagerObserver() override = default;
 };
 
 }  // namespace ui
 
-#endif  // UI_BASE_CURSOR_CURSOR_THEME_MANAGER_LINUX_OBSERVER_H_
+#endif  // UI_BASE_CURSOR_CURSOR_THEME_MANAGER_OBSERVER_H_
diff --git a/chromium/ui/base/cursor/cursor_unittest.cc b/chromium/ui/base/cursor/cursor_unittest.cc
index ef2d9e1e58f..d69ecfcc2cd 100644
--- a/chromium/ui/base/cursor/cursor_unittest.cc
+++ b/chromium/ui/base/cursor/cursor_unittest.cc
@@ -4,12 +4,10 @@
 
 #include "ui/base/cursor/cursor.h"
 
-#include <algorithm>
-
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-#include "ui/base/cursor/cursor_lookup.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
+#include "ui/gfx/geometry/point.h"
 #include "ui/gfx/skia_util.h"
 
 namespace ui {
@@ -38,22 +36,21 @@ TEST(CursorTest, CustomType) {
 
   const gfx::Point kHotspot = gfx::Point(5, 2);
   cursor.set_custom_hotspot(kHotspot);
-  EXPECT_EQ(kHotspot, GetCursorHotspot(cursor));
+  EXPECT_EQ(kHotspot, cursor.custom_hotspot());
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(10, 10);
   bitmap.eraseColor(SK_ColorRED);
   cursor.set_custom_bitmap(bitmap);
 
-  EXPECT_EQ(bitmap.getGenerationID(),
-            GetCursorBitmap(cursor).getGenerationID());
-  EXPECT_TRUE(gfx::BitmapsAreEqual(bitmap, GetCursorBitmap(cursor)));
+  EXPECT_EQ(bitmap.getGenerationID(), cursor.custom_bitmap().getGenerationID());
+  EXPECT_TRUE(gfx::BitmapsAreEqual(bitmap, cursor.custom_bitmap()));
 
   Cursor copy(cursor);
-  EXPECT_EQ(GetCursorBitmap(cursor).getGenerationID(),
-            GetCursorBitmap(copy).getGenerationID());
+  EXPECT_EQ(cursor.custom_bitmap().getGenerationID(),
+            copy.custom_bitmap().getGenerationID());
   EXPECT_TRUE(
-      gfx::BitmapsAreEqual(GetCursorBitmap(cursor), GetCursorBitmap(copy)));
+      gfx::BitmapsAreEqual(cursor.custom_bitmap(), copy.custom_bitmap()));
   EXPECT_EQ(cursor, copy);
 }
 
@@ -71,10 +68,10 @@ TEST(CursorTest, CustomTypeComparesBitmapPixels) {
   bitmap2.eraseColor(SK_ColorRED);
   cursor2.set_custom_bitmap(bitmap2);
 
-  EXPECT_NE(GetCursorBitmap(cursor1).getGenerationID(),
-            GetCursorBitmap(cursor2).getGenerationID());
+  EXPECT_NE(cursor1.custom_bitmap().getGenerationID(),
+            cursor2.custom_bitmap().getGenerationID());
   EXPECT_TRUE(
-      gfx::BitmapsAreEqual(GetCursorBitmap(cursor1), GetCursorBitmap(cursor2)));
+      gfx::BitmapsAreEqual(cursor1.custom_bitmap(), cursor2.custom_bitmap()));
   EXPECT_EQ(cursor1, cursor2);
 }
 
diff --git a/chromium/ui/base/cursor/cursor_util.cc b/chromium/ui/base/cursor/cursor_util.cc
index 4af26e57833..a19a4ddcf1e 100644
--- a/chromium/ui/base/cursor/cursor_util.cc
+++ b/chromium/ui/base/cursor/cursor_util.cc
@@ -6,8 +6,11 @@
 
 #include "base/check_op.h"
 #include "base/notreached.h"
+#include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/skbitmap_operations.h"
diff --git a/chromium/ui/base/cursor/cursor_util.h b/chromium/ui/base/cursor/cursor_util.h
index fc93f2150f4..1fe3277c509 100644
--- a/chromium/ui/base/cursor/cursor_util.h
+++ b/chromium/ui/base/cursor/cursor_util.h
@@ -7,22 +7,25 @@
 
 #include <vector>
 
-#include "base/compiler_specific.h"
-#include "third_party/skia/include/core/SkBitmap.h"
-#include "ui/base/ui_base_export.h"
+#include "base/component_export.h"
 #include "ui/display/display.h"
-#include "ui/gfx/geometry/point.h"
+
+class SkBitmap;
+
+namespace gfx {
+class Point;
+}
 
 namespace ui {
 
 // Scale and rotate the cursor's bitmap and hotpoint.
 // |bitmap_in_out| and |hotpoint_in_out| are used as
 // both input and output.
-UI_BASE_EXPORT void ScaleAndRotateCursorBitmapAndHotpoint(
-    float scale,
-    display::Display::Rotation rotation,
-    SkBitmap* bitmap_in_out,
-    gfx::Point* hotpoint_in_out);
+COMPONENT_EXPORT(UI_BASE_CURSOR)
+void ScaleAndRotateCursorBitmapAndHotpoint(float scale,
+                                           display::Display::Rotation rotation,
+                                           SkBitmap* bitmap_in_out,
+                                           gfx::Point* hotpoint_in_out);
 
 // Helpers for CursorLoader.
 void GetImageCursorBitmap(int resource_id,
diff --git a/chromium/ui/base/cursor/cursor_util_unittest.cc b/chromium/ui/base/cursor/cursor_util_unittest.cc
index 1e2d55f6385..89cb58fc873 100644
--- a/chromium/ui/base/cursor/cursor_util_unittest.cc
+++ b/chromium/ui/base/cursor/cursor_util_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/geometry/point.h"
 
 namespace ui {
 namespace {
diff --git a/chromium/ui/base/cursor/cursor_x11.cc b/chromium/ui/base/cursor/cursor_x11.cc
deleted file mode 100644
index edf6c9bb6ba..00000000000
--- a/chromium/ui/base/cursor/cursor_x11.cc
+++ /dev/null
@@ -1,21 +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"
-
-#include "ui/base/x/x11_util.h"
-
-namespace ui {
-
-void Cursor::RefCustomCursor() {
-  if (platform_cursor_)
-    ui::RefCustomXCursor(platform_cursor_);
-}
-
-void Cursor::UnrefCustomCursor() {
-  if (platform_cursor_)
-    ui::UnrefCustomXCursor(platform_cursor_);
-}
-
-}  // namespace ui
diff --git a/chromium/ui/base/cursor/cursors_aura.cc b/chromium/ui/base/cursor/cursors_aura.cc
index 2a7ba7784c1..710fb8dba11 100644
--- a/chromium/ui/base/cursor/cursors_aura.cc
+++ b/chromium/ui/base/cursor/cursors_aura.cc
@@ -9,6 +9,7 @@
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/cursor_size.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
 #include "ui/base/resource/resource_bundle.h"
@@ -22,6 +23,7 @@
 #endif
 
 namespace ui {
+
 namespace {
 
 struct HotPoint {
@@ -282,120 +284,6 @@ bool SearchTable(const CursorData* table,
 
 }  // namespace
 
-const char* CursorCssNameFromId(mojom::CursorType id) {
-  switch (id) {
-    case mojom::CursorType::kMiddlePanning:
-      return "all-scroll";
-    case mojom::CursorType::kMiddlePanningVertical:
-      return "v-scroll";
-    case mojom::CursorType::kMiddlePanningHorizontal:
-      return "h-scroll";
-    case mojom::CursorType::kEastPanning:
-      return "e-resize";
-    case mojom::CursorType::kNorthPanning:
-      return "n-resize";
-    case mojom::CursorType::kNorthEastPanning:
-      return "ne-resize";
-    case mojom::CursorType::kNorthWestPanning:
-      return "nw-resize";
-    case mojom::CursorType::kSouthPanning:
-      return "s-resize";
-    case mojom::CursorType::kSouthEastPanning:
-      return "se-resize";
-    case mojom::CursorType::kSouthWestPanning:
-      return "sw-resize";
-    case mojom::CursorType::kWestPanning:
-      return "w-resize";
-    case mojom::CursorType::kNone:
-      return "none";
-    case mojom::CursorType::kGrab:
-      return "grab";
-    case mojom::CursorType::kGrabbing:
-      return "grabbing";
-    case mojom::CursorType::kNull:
-      return "left_ptr";
-    case mojom::CursorType::kPointer:
-      return "left_ptr";
-    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.
-      return "all-scroll";
-    case mojom::CursorType::kCross:
-      return "crosshair";
-    case mojom::CursorType::kHand:
-      return "pointer";
-    case mojom::CursorType::kIBeam:
-      return "text";
-    case mojom::CursorType::kProgress:
-      return "progress";
-    case mojom::CursorType::kWait:
-      return "wait";
-    case mojom::CursorType::kHelp:
-      return "help";
-    case mojom::CursorType::kEastResize:
-      return "e-resize";
-    case mojom::CursorType::kNorthResize:
-      return "n-resize";
-    case mojom::CursorType::kNorthEastResize:
-      return "ne-resize";
-    case mojom::CursorType::kNorthWestResize:
-      return "nw-resize";
-    case mojom::CursorType::kSouthResize:
-      return "s-resize";
-    case mojom::CursorType::kSouthEastResize:
-      return "se-resize";
-    case mojom::CursorType::kSouthWestResize:
-      return "sw-resize";
-    case mojom::CursorType::kWestResize:
-      return "w-resize";
-    case mojom::CursorType::kNorthSouthResize:
-      return "ns-resize";
-    case mojom::CursorType::kEastWestResize:
-      return "ew-resize";
-    case mojom::CursorType::kColumnResize:
-      return "col-resize";
-    case mojom::CursorType::kRowResize:
-      return "row-resize";
-    case mojom::CursorType::kNorthEastSouthWestResize:
-      return "nesw-resize";
-    case mojom::CursorType::kNorthWestSouthEastResize:
-      return "nwse-resize";
-    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";
-    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";
-    case mojom::CursorType::kDndNone:
-      return "dnd-none";
-    case mojom::CursorType::kDndMove:
-      return "dnd-move";
-    case mojom::CursorType::kDndCopy:
-      return "dnd-copy";
-    case mojom::CursorType::kDndLink:
-      return "dnd-link";
-    case mojom::CursorType::kCustom:
-      NOTREACHED();
-      return "left_ptr";
-  }
-  NOTREACHED() << "Case not handled for " << static_cast<int>(id);
-  return "left_ptr";
-}
-
 bool GetCursorDataFor(CursorSize cursor_size,
                       mojom::CursorType id,
                       float scale_factor,
diff --git a/chromium/ui/base/cursor/cursors_aura.h b/chromium/ui/base/cursor/cursors_aura.h
index 778a5d3c871..cc82d976546 100644
--- a/chromium/ui/base/cursor/cursors_aura.h
+++ b/chromium/ui/base/cursor/cursors_aura.h
@@ -5,9 +5,8 @@
 #ifndef UI_BASE_CURSOR_CURSORS_AURA_H_
 #define UI_BASE_CURSOR_CURSORS_AURA_H_
 
-#include "ui/base/cursor/cursor.h"
+#include "base/component_export.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
-#include "ui/base/ui_base_export.h"
 
 class SkBitmap;
 
@@ -16,29 +15,29 @@ class Point;
 }
 
 namespace ui {
+class Cursor;
 enum class CursorSize;
 
 const int kAnimatedCursorFrameDelayMs = 25;
 
-// Returns CSS cursor name from an Aura cursor ID.
-UI_BASE_EXPORT const char* CursorCssNameFromId(mojom::CursorType id);
-
 // Returns data about |id|, where id is a cursor constant like
 // ui::mojom::CursorType::kHelp. The IDR will be placed in |resource_id| and
 // the hotspots for the different DPIs will be placed in |hot_1x| and
 // |hot_2x|.  Returns false if |id| is invalid.
-UI_BASE_EXPORT bool GetCursorDataFor(CursorSize cursor_size,
-                                     mojom::CursorType id,
-                                     float scale_factor,
-                                     int* resource_id,
-                                     gfx::Point* point);
+COMPONENT_EXPORT(UI_BASE_CURSOR)
+bool GetCursorDataFor(CursorSize cursor_size,
+                      mojom::CursorType id,
+                      float scale_factor,
+                      int* resource_id,
+                      gfx::Point* point);
 
 // Like above, but for animated cursors.
-UI_BASE_EXPORT bool GetAnimatedCursorDataFor(CursorSize cursor_size,
-                                             mojom::CursorType id,
-                                             float scale_factor,
-                                             int* resource_id,
-                                             gfx::Point* point);
+COMPONENT_EXPORT(UI_BASE_CURSOR)
+bool GetAnimatedCursorDataFor(CursorSize cursor_size,
+                              mojom::CursorType id,
+                              float scale_factor,
+                              int* resource_id,
+                              gfx::Point* point);
 
 SkBitmap GetDefaultBitmap(const Cursor& cursor);
 
diff --git a/chromium/ui/base/cursor/image_cursors.cc b/chromium/ui/base/cursor/image_cursors.cc
index 4612bedb350..42fd3249684 100644
--- a/chromium/ui/base/cursor/image_cursors.cc
+++ b/chromium/ui/base/cursor/image_cursors.cc
@@ -4,25 +4,17 @@
 
 #include "ui/base/cursor/image_cursors.h"
 
-#include <float.h>
-#include <stddef.h>
-
 #include "base/check.h"
-#include "base/notreached.h"
-#include "base/stl_util.h"
-#include "base/strings/string16.h"
-#include "ui/base/cursor/cursor.h"
 #include "ui/base/cursor/cursor_loader.h"
 #include "ui/base/cursor/cursors_aura.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
-#include "ui/display/display.h"
 #include "ui/gfx/geometry/point.h"
 
 namespace ui {
 
 namespace {
 
-const mojom::CursorType kImageCursorIds[] = {
+constexpr mojom::CursorType kImageCursorIds[] = {
     mojom::CursorType::kNull,
     mojom::CursorType::kPointer,
     mojom::CursorType::kNoDrop,
@@ -57,49 +49,30 @@ const mojom::CursorType kImageCursorIds[] = {
     mojom::CursorType::kGrabbing,
 };
 
-const mojom::CursorType kAnimatedCursorIds[] = {mojom::CursorType::kWait,
-                                                mojom::CursorType::kProgress};
+constexpr mojom::CursorType kAnimatedCursorIds[] = {
+    mojom::CursorType::kWait, mojom::CursorType::kProgress};
 
 }  // namespace
 
-ImageCursors::ImageCursors() : cursor_size_(CursorSize::kNormal) {}
+ImageCursors::ImageCursors()
+    : cursor_loader_(CursorLoader::Create()),
+      cursor_size_(CursorSize::kNormal) {}
 
-ImageCursors::~ImageCursors() {
-}
-
-void ImageCursors::Initialize() {
-  if (!cursor_loader_)
-    cursor_loader_.reset(CursorLoader::Create());
-}
+ImageCursors::~ImageCursors() = default;
 
 float ImageCursors::GetScale() const {
-  if (!cursor_loader_) {
-    NOTREACHED();
-    // Returning default on release build as it's not serious enough to crash
-    // even if this ever happens.
-    return 1.0f;
-  }
   return cursor_loader_->scale();
 }
 
 display::Display::Rotation ImageCursors::GetRotation() const {
-  if (!cursor_loader_) {
-    NOTREACHED();
-    // Returning default on release build as it's not serious enough to crash
-    // even if this ever happens.
-    return display::Display::ROTATE_0;
-  }
   return cursor_loader_->rotation();
 }
 
 bool ImageCursors::SetDisplay(const display::Display& display,
                               float scale_factor) {
-  if (!cursor_loader_) {
-    cursor_loader_.reset(CursorLoader::Create());
-  } else if (cursor_loader_->rotation() == display.panel_rotation() &&
-             cursor_loader_->scale() == scale_factor) {
+  if (cursor_loader_->rotation() == display.panel_rotation() &&
+      cursor_loader_->scale() == scale_factor)
     return false;
-  }
 
   cursor_loader_->set_rotation(display.panel_rotation());
   cursor_loader_->set_scale(scale_factor);
@@ -112,25 +85,21 @@ void ImageCursors::ReloadCursors() {
 
   cursor_loader_->UnloadAll();
 
-  for (size_t i = 0; i < base::size(kImageCursorIds); ++i) {
+  for (auto cursor_id : kImageCursorIds) {
     int resource_id = -1;
     gfx::Point hot_point;
-    bool success =
-        GetCursorDataFor(cursor_size_, kImageCursorIds[i], device_scale_factor,
-                         &resource_id, &hot_point);
+    bool success = GetCursorDataFor(
+        cursor_size_, cursor_id, device_scale_factor, &resource_id, &hot_point);
     DCHECK(success);
-    cursor_loader_->LoadImageCursor(kImageCursorIds[i], resource_id, hot_point);
+    cursor_loader_->LoadImageCursor(cursor_id, resource_id, hot_point);
   }
-  for (size_t i = 0; i < base::size(kAnimatedCursorIds); ++i) {
+  for (auto cursor_id : kAnimatedCursorIds) {
     int resource_id = -1;
     gfx::Point hot_point;
-    bool success =
-        GetAnimatedCursorDataFor(cursor_size_, kAnimatedCursorIds[i],
-                                 device_scale_factor, &resource_id, &hot_point);
+    bool success = GetAnimatedCursorDataFor(
+        cursor_size_, cursor_id, device_scale_factor, &resource_id, &hot_point);
     DCHECK(success);
-    cursor_loader_->LoadAnimatedCursor(kAnimatedCursorIds[i],
-                                       resource_id,
-                                       hot_point,
+    cursor_loader_->LoadAnimatedCursor(cursor_id, resource_id, hot_point,
                                        kAnimatedCursorFrameDelayMs);
   }
 }
@@ -141,16 +110,11 @@ void ImageCursors::SetCursorSize(CursorSize cursor_size) {
 
   cursor_size_ = cursor_size;
 
-  if (cursor_loader_.get())
-    ReloadCursors();
+  ReloadCursors();
 }
 
 void ImageCursors::SetPlatformCursor(gfx::NativeCursor* cursor) {
   cursor_loader_->SetPlatformCursor(cursor);
 }
 
-base::WeakPtr<ImageCursors> ImageCursors::GetWeakPtr() {
-  return weak_ptr_factory_.GetWeakPtr();
-}
-
 }  // namespace ui
diff --git a/chromium/ui/base/cursor/image_cursors.h b/chromium/ui/base/cursor/image_cursors.h
index 0855bfff15e..b5b5ec274dd 100644
--- a/chromium/ui/base/cursor/image_cursors.h
+++ b/chromium/ui/base/cursor/image_cursors.h
@@ -7,12 +7,8 @@
 
 #include <memory>
 
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/strings/string16.h"
-#include "ui/base/cursor/cursor.h"
+#include "base/component_export.h"
 #include "ui/base/cursor/cursor_size.h"
-#include "ui/base/ui_base_export.h"
 #include "ui/display/display.h"
 #include "ui/gfx/native_widget_types.h"
 
@@ -22,19 +18,13 @@ class CursorLoader;
 
 // A utility class that provides cursors for NativeCursors for which we have
 // image resources.
-class UI_BASE_EXPORT ImageCursors {
+class COMPONENT_EXPORT(UI_BASE_CURSOR) ImageCursors {
  public:
   ImageCursors();
+  ImageCursors(const ImageCursors&) = delete;
+  ImageCursors& operator=(const ImageCursors&) = delete;
   ~ImageCursors();
 
-  // Creates the |cursor_loader_|. This is optional as |cursor_loader_| is
-  // lazily created if Initialize() isn't explictly called.
-  // However note that it matters which thread is used to create
-  // |cursor_loader_| (see CursorLoaderOzone,  crbug.com/741106). Thus explicit
-  // call to Initialize may be useful to ensure initialization happens on the
-  // right thread.
-  void Initialize();
-
   // Returns the scale and rotation of the currently loaded cursor.
   float GetScale() const;
   display::Display::Rotation GetRotation() const;
@@ -49,17 +39,12 @@ class UI_BASE_EXPORT ImageCursors {
   // Sets the platform cursor based on the native type of |cursor|.
   void SetPlatformCursor(gfx::NativeCursor* cursor);
 
-  base::WeakPtr<ImageCursors> GetWeakPtr();
-
  private:
   // Reloads the all loaded cursors in the cursor loader.
   void ReloadCursors();
 
   std::unique_ptr<CursorLoader> cursor_loader_;
   CursorSize cursor_size_;
-  base::WeakPtrFactory<ImageCursors> weak_ptr_factory_{this};
-
-  DISALLOW_COPY_AND_ASSIGN(ImageCursors);
 };
 
 }  // namespace ui
diff --git a/chromium/ui/base/cursor/mojom/BUILD.gn b/chromium/ui/base/cursor/mojom/BUILD.gn
index 042d2160861..588e828c29d 100644
--- a/chromium/ui/base/cursor/mojom/BUILD.gn
+++ b/chromium/ui/base/cursor/mojom/BUILD.gn
@@ -33,7 +33,7 @@ source_set("mojom_traits") {
   ]
   public_deps = [
     ":mojom_shared",
-    "//ui/base/cursor",
+    "//ui/base/cursor:cursor_base",
   ]
   deps = [
     "//skia",
@@ -56,7 +56,7 @@ source_set("unittests") {
     ":mojom_traits",
     "//testing/gtest",
     "//ui/base",
-    "//ui/base/cursor",
+    "//ui/base/cursor:cursor_base",
     "//ui/gfx:geometry_skia",
     "//ui/gfx/geometry/mojom:mojom_traits",
   ]
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 d3b1aee2f12..88f888b2709 100644
--- a/chromium/ui/base/cursor/mojom/cursor_mojom_traits_unittest.cc
+++ b/chromium/ui/base/cursor/mojom/cursor_mojom_traits_unittest.cc
@@ -7,7 +7,6 @@
 #include "skia/public/mojom/bitmap_skbitmap_mojom_traits.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/cursor/cursor.h"
-#include "ui/base/cursor/cursor_lookup.h"
 #include "ui/base/cursor/mojom/cursor.mojom.h"
 #include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
 #include "ui/gfx/geometry/mojom/geometry_mojom_traits.h"
@@ -59,18 +58,18 @@ TEST_F(CursorStructTraitsTest, TestBitmapCursor) {
 
   EXPECT_EQ(ui::mojom::CursorType::kCustom, output.type());
   EXPECT_EQ(kScale, output.image_scale_factor());
-  EXPECT_EQ(kHotspot, GetCursorHotspot(output));
+  EXPECT_EQ(kHotspot, output.custom_hotspot());
 
   // Even though the pixel data is the same, the bitmap generation ids differ.
   EXPECT_TRUE(
-      gfx::BitmapsAreEqual(GetCursorBitmap(input), GetCursorBitmap(output)));
-  EXPECT_NE(GetCursorBitmap(input).getGenerationID(),
-            GetCursorBitmap(output).getGenerationID());
+      gfx::BitmapsAreEqual(input.custom_bitmap(), output.custom_bitmap()));
+  EXPECT_NE(input.custom_bitmap().getGenerationID(),
+            output.custom_bitmap().getGenerationID());
 
   // Make a copy of output; the bitmap generation ids should be the same.
   ui::Cursor copy = output;
-  EXPECT_EQ(GetCursorBitmap(output).getGenerationID(),
-            GetCursorBitmap(copy).getGenerationID());
+  EXPECT_EQ(output.custom_bitmap().getGenerationID(),
+            copy.custom_bitmap().getGenerationID());
   EXPECT_EQ(input, output);
 }
 
@@ -88,7 +87,7 @@ TEST_F(CursorStructTraitsTest, TestEmptyCursor) {
   ui::Cursor output;
   ASSERT_TRUE(EchoCursor(input, &output));
 
-  EXPECT_TRUE(GetCursorBitmap(output).empty());
+  EXPECT_TRUE(output.custom_bitmap().empty());
 }
 
 // Test that various device scale factors are passed correctly over the wire.
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 44037bc6142..e86f70ea603 100644
--- a/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.cc
+++ b/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.cc
@@ -7,10 +7,6 @@
 #include <algorithm>
 
 #include "base/check_op.h"
-#include "third_party/skia/include/core/SkBitmap.h"
-#include "ui/base/cursor/cursor_lookup.h"
-#include "ui/base/cursor/cursors_aura.h"
-#include "ui/base/cursor/mojom/cursor_type.mojom-shared.h"
 
 namespace ui {
 
@@ -24,20 +20,6 @@ PlatformCursor ToPlatformCursor(BitmapCursorOzone* cursor) {
   return static_cast<PlatformCursor>(cursor);
 }
 
-scoped_refptr<BitmapCursorOzone> CreateDefaultBitmapCursor(
-    mojom::CursorType type) {
-  Cursor cursor(type);
-  // Ozone must honor the lowest possible scale value, which is 1.0f. Otherwise,
-  // it can happen that cursor chooses wrong hotspots if max scaling value is
-  // set to 200p, for example.
-  cursor.set_image_scale_factor(1.0f);
-  SkBitmap bitmap = GetCursorBitmap(cursor);
-  gfx::Point hotspot = GetCursorHotspot(cursor);
-  if (!bitmap.isNull())
-    return new BitmapCursorOzone(bitmap, hotspot);
-  return nullptr;
-}
-
 }  // namespace
 
 BitmapCursorOzone::BitmapCursorOzone(const SkBitmap& bitmap,
@@ -89,15 +71,16 @@ scoped_refptr<BitmapCursorOzone> BitmapCursorFactoryOzone::GetBitmapCursor(
   return base::WrapRefCounted(ToBitmapCursorOzone(platform_cursor));
 }
 
-PlatformCursor BitmapCursorFactoryOzone::GetDefaultCursor(
+base::Optional<PlatformCursor> BitmapCursorFactoryOzone::GetDefaultCursor(
     mojom::CursorType type) {
-  return GetDefaultCursorInternal(type).get();
+  if (type == mojom::CursorType::kNone)
+    return nullptr;  // nullptr is used for the hidden cursor.
+  return base::nullopt;
 }
 
 PlatformCursor BitmapCursorFactoryOzone::CreateImageCursor(
     const SkBitmap& bitmap,
-    const gfx::Point& hotspot,
-    float bitmap_dpi) {
+    const gfx::Point& hotspot) {
   BitmapCursorOzone* cursor = new BitmapCursorOzone(bitmap, hotspot);
   cursor->AddRef();  // Balanced by UnrefImageCursor.
   return ToPlatformCursor(cursor);
@@ -106,8 +89,7 @@ PlatformCursor BitmapCursorFactoryOzone::CreateImageCursor(
 PlatformCursor BitmapCursorFactoryOzone::CreateAnimatedCursor(
     const std::vector<SkBitmap>& bitmaps,
     const gfx::Point& hotspot,
-    int frame_delay_ms,
-    float bitmap_dpi) {
+    int frame_delay_ms) {
   DCHECK_LT(0U, bitmaps.size());
   BitmapCursorOzone* cursor =
       new BitmapCursorOzone(bitmaps, hotspot, frame_delay_ms);
@@ -123,23 +105,4 @@ void BitmapCursorFactoryOzone::UnrefImageCursor(PlatformCursor cursor) {
   ToBitmapCursorOzone(cursor)->Release();
 }
 
-scoped_refptr<BitmapCursorOzone>
-BitmapCursorFactoryOzone::GetDefaultCursorInternal(mojom::CursorType type) {
-  if (type == mojom::CursorType::kNone)
-    return nullptr;  // Null is used for hidden cursor.
-
-  if (!default_cursors_.count(type)) {
-    // Create new image cursor from default aura bitmap for this type. We hold a
-    // ref forever because clients do not do refcounting for default cursors.
-    scoped_refptr<BitmapCursorOzone> cursor = CreateDefaultBitmapCursor(type);
-    if (!cursor.get() && type != mojom::CursorType::kPointer)
-      cursor = GetDefaultCursorInternal(mojom::CursorType::kPointer);
-    DCHECK(cursor.get()) << "Failed to load default cursor bitmap";
-    default_cursors_[type] = cursor;
-  }
-
-  // Returned owned default cursor for this type.
-  return default_cursors_[type];
-}
-
 }  // namespace ui
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 95ed10b051b..b489e099ad0 100644
--- a/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h
+++ b/chromium/ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h
@@ -5,21 +5,20 @@
 #ifndef UI_BASE_CURSOR_OZONE_BITMAP_CURSOR_FACTORY_OZONE_H_
 #define UI_BASE_CURSOR_OZONE_BITMAP_CURSOR_FACTORY_OZONE_H_
 
-#include <map>
+#include <vector>
 
+#include "base/component_export.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/cursor/cursor.h"
-#include "ui/base/cursor/mojom/cursor_type.mojom-forward.h"
-#include "ui/base/ui_base_export.h"
+#include "ui/base/cursor/cursor_factory.h"
 #include "ui/gfx/geometry/point.h"
-#include "ui/ozone/public/cursor_factory_ozone.h"
 
 namespace ui {
 
 // A cursor that is an SkBitmap combined with a gfx::Point hotspot.
-class UI_BASE_EXPORT BitmapCursorOzone
+class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorOzone
     : public base::RefCounted<BitmapCursorOzone> {
  public:
   BitmapCursorOzone(const SkBitmap& bitmap, const gfx::Point& hotspot);
@@ -45,14 +44,15 @@ class UI_BASE_EXPORT BitmapCursorOzone
   DISALLOW_COPY_AND_ASSIGN(BitmapCursorOzone);
 };
 
-// CursorFactoryOzone implementation for bitmapped cursors.
+// CursorFactory implementation for bitmapped cursors.
 //
 // 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 UI_BASE_EXPORT BitmapCursorFactoryOzone : public CursorFactoryOzone {
+class COMPONENT_EXPORT(UI_BASE_CURSOR) BitmapCursorFactoryOzone
+    : public CursorFactory {
  public:
   BitmapCursorFactoryOzone();
   ~BitmapCursorFactoryOzone() override;
@@ -62,26 +62,17 @@ class UI_BASE_EXPORT BitmapCursorFactoryOzone : public CursorFactoryOzone {
       PlatformCursor platform_cursor);
 
   // CursorFactoryOzone:
-  PlatformCursor GetDefaultCursor(mojom::CursorType type) override;
+  base::Optional<PlatformCursor> GetDefaultCursor(
+      mojom::CursorType type) override;
   PlatformCursor CreateImageCursor(const SkBitmap& bitmap,
-                                   const gfx::Point& hotspot,
-                                   float bitmap_dpi) override;
+                                   const gfx::Point& hotspot) override;
   PlatformCursor CreateAnimatedCursor(const std::vector<SkBitmap>& bitmaps,
                                       const gfx::Point& hotspot,
-                                      int frame_delay_ms,
-                                      float bitmap_dpi) override;
+                                      int frame_delay_ms) override;
   void RefImageCursor(PlatformCursor cursor) override;
   void UnrefImageCursor(PlatformCursor cursor) override;
 
  private:
-  // Get cached BitmapCursorOzone for a default cursor.
-  scoped_refptr<BitmapCursorOzone> GetDefaultCursorInternal(
-      mojom::CursorType type);
-
-  // Default cursors are cached & owned by the factory.
-  std::map<mojom::CursorType, scoped_refptr<BitmapCursorOzone>>
-      default_cursors_;
-
   DISALLOW_COPY_AND_ASSIGN(BitmapCursorFactoryOzone);
 };