BASELINE: Update Chromium to 85.0.4183.14085-based

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

30 files changed, 413 insertions, 90 deletions

diff --git a/chromium/ui/ozone/platform/drm/BUILD.gn b/chromium/ui/ozone/platform/drm/BUILD.gn
index 0ef7cd7e786..01ed60608fd 100644
--- a/chromium/ui/ozone/platform/drm/BUILD.gn
+++ b/chromium/ui/ozone/platform/drm/BUILD.gn
@@ -127,6 +127,8 @@ source_set("gbm") {
     "//third_party/libsync",
     "//third_party/minigbm",
     "//ui/base",
+    "//ui/base/cursor",
+    "//ui/base/cursor:cursor_base",
     "//ui/base/ime",
     "//ui/display",
     "//ui/display/types",
@@ -178,6 +180,7 @@ source_set("gbm_unittests") {
   testonly = true
   sources = [
     "common/drm_util_unittest.cc",
+    "gpu/drm_display_unittest.cc",
     "gpu/drm_overlay_manager_unittest.cc",
     "gpu/drm_overlay_validator_unittest.cc",
     "gpu/drm_thread_unittest.cc",
diff --git a/chromium/ui/ozone/platform/drm/common/drm_util.cc b/chromium/ui/ozone/platform/drm/common/drm_util.cc
index 7ac144c6bdf..656330d42bf 100644
--- a/chromium/ui/ozone/platform/drm/common/drm_util.cc
+++ b/chromium/ui/ozone/platform/drm/common/drm_util.cc
@@ -18,6 +18,7 @@
 #include "base/containers/flat_map.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_functions.h"
+#include "base/notreached.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/util/display_util.h"
@@ -210,7 +211,7 @@ display::PanelOrientation GetPanelOrientation(int fd,
   int index = GetDrmProperty(fd, connector, "panel orientation", &property);
   if (index < 0)
     return display::PanelOrientation::kNormal;
-  DCHECK_LT(connector->prop_values[index], display::PanelOrientation::kLast);
+  DCHECK_LE(connector->prop_values[index], display::PanelOrientation::kLast);
   return static_cast<display::PanelOrientation>(connector->prop_values[index]);
 }
 
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_device.h b/chromium/ui/ozone/platform/drm/gpu/drm_device.h
index 0cbcca2fe96..fdc7f2d0a38 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_device.h
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_device.h
@@ -240,6 +240,7 @@ class DrmDevice : public base::RefCountedThreadSafe<DrmDevice> {
 
  protected:
   friend class base::RefCountedThreadSafe<DrmDevice>;
+  friend class DrmDisplayTest;
 
   virtual ~DrmDevice();
 
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_device_manager.cc b/chromium/ui/ozone/platform/drm/gpu/drm_device_manager.cc
index 5d879fa9853..9b1a8b2a4a6 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_device_manager.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_device_manager.cc
@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "base/file_descriptor_posix.h"
+#include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_display.cc b/chromium/ui/ozone/platform/drm/gpu/drm_display.cc
index 89b9ea98bb4..0866e1989ed 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_display.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_display.cc
@@ -7,10 +7,13 @@
 #include <xf86drmMode.h>
 #include <memory>
 
+#include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
+#include "ui/display/display_features.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
+#include "ui/gfx/color_space.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
@@ -82,12 +85,24 @@ std::vector<drmModeModeInfo> GetDrmModeVector(drmModeConnector* connector) {
   return modes;
 }
 
+void FillLinearValues(std::vector<display::GammaRampRGBEntry>* table,
+                      size_t table_size,
+                      float max_value) {
+  for (size_t i = 0; i < table_size; i++) {
+    const uint16_t v =
+        max_value * std::numeric_limits<uint16_t>::max() * i / (table_size - 1);
+    struct display::GammaRampRGBEntry gamma_entry = {v, v, v};
+    table->push_back(gamma_entry);
+  }
+}
+
 }  // namespace
 
 DrmDisplay::DrmDisplay(ScreenManager* screen_manager,
                        const scoped_refptr<DrmDevice>& drm)
-    : screen_manager_(screen_manager), drm_(drm) {
-}
+    : screen_manager_(screen_manager),
+      drm_(drm),
+      current_color_space_(gfx::ColorSpace::CreateSRGB()) {}
 
 DrmDisplay::~DrmDisplay() {
 }
@@ -112,6 +127,14 @@ std::unique_ptr<display::DisplaySnapshot> DrmDisplay::Update(
 
   display_id_ = params->display_id();
   modes_ = GetDrmModeVector(info->connector());
+  is_hdr_capable_ =
+      params->bits_per_channel() > 8 && params->color_space().IsHDR();
+#if defined(OS_CHROMEOS)
+  is_hdr_capable_ =
+      is_hdr_capable_ &&
+      base::FeatureList::IsEnabled(display::features::kUseHDRTransferFunction);
+#endif
+
   return params;
 }
 
@@ -202,10 +225,14 @@ void DrmDisplay::SetBackgroundColor(const uint64_t background_color) {
 void DrmDisplay::SetGammaCorrection(
     const std::vector<display::GammaRampRGBEntry>& degamma_lut,
     const std::vector<display::GammaRampRGBEntry>& gamma_lut) {
-  if (!drm_->plane_manager()->SetGammaCorrection(crtc_, degamma_lut,
-                                                 gamma_lut)) {
-    LOG(ERROR) << "Failed to set gamma tables for display: crtc_id = " << crtc_;
-  }
+  // When both |degamma_lut| and |gamma_lut| are empty they are interpreted as
+  // "linear/pass-thru" [1]. If the display |is_hdr_capable_| we have to make
+  // sure the |current_color_space_| is considered properly.
+  // [1] https://www.kernel.org/doc/html/v4.19/gpu/drm-kms.html#color-management-properties
+  if (degamma_lut.empty() && gamma_lut.empty() && is_hdr_capable_)
+    SetColorSpace(current_color_space_);
+  else
+    CommitGammaCorrection(degamma_lut, gamma_lut);
 }
 
 // TODO(gildekel): consider reformatting this to use the new DRM API or cache
@@ -229,4 +256,35 @@ void DrmDisplay::SetPrivacyScreen(bool enabled) {
   }
 }
 
+void DrmDisplay::SetColorSpace(const gfx::ColorSpace& color_space) {
+  // There's only something to do if the display supports HDR.
+  if (!is_hdr_capable_)
+    return;
+  current_color_space_ = color_space;
+
+  // When |color_space| is HDR we can simply leave the gamma tables empty, which
+  // is interpreted as "linear/pass-thru", see [1]. However when we have an SDR
+  // |color_space|, we need to write a scaled down |gamma| function to prevent
+  // the mode change brightness to be visible.
+  std::vector<display::GammaRampRGBEntry> degamma;
+  std::vector<display::GammaRampRGBEntry> gamma;
+  if (current_color_space_.IsHDR())
+    return CommitGammaCorrection(degamma, gamma);
+
+  // TODO(mcasas) This should be the same value as in DisplayChangeObservers's
+  // FillDisplayColorSpaces, move to a common place.
+  constexpr float kHDRLevel = 2.0;
+  // TODO(mcasas): Retrieve this from the |drm_| HardwareDisplayPlaneManager.
+  constexpr size_t kNumGammaSamples = 16ul;
+  FillLinearValues(&gamma, kNumGammaSamples, 1.0 / kHDRLevel);
+  CommitGammaCorrection(degamma, gamma);
+}
+
+void DrmDisplay::CommitGammaCorrection(
+    const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+    const std::vector<display::GammaRampRGBEntry>& gamma_lut) {
+  if (!drm_->plane_manager()->SetGammaCorrection(crtc_, degamma_lut, gamma_lut))
+    LOG(ERROR) << "Failed to set gamma tables for display: crtc_id = " << crtc_;
+}
+
 }  // namespace ui
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_display.h b/chromium/ui/ozone/platform/drm/gpu/drm_display.h
index de721282b28..a658477fc2d 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_display.h
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_display.h
@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "ui/display/types/display_constants.h"
+#include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/ozone/platform/drm/common/scoped_drm_types.h"
 
@@ -24,7 +25,6 @@ struct GammaRampRGBEntry;
 }
 
 namespace ui {
-
 class DrmDevice;
 class HardwareDisplayControllerInfo;
 class ScreenManager;
@@ -54,8 +54,15 @@ class DrmDisplay {
       const std::vector<display::GammaRampRGBEntry>& degamma_lut,
       const std::vector<display::GammaRampRGBEntry>& gamma_lut);
   void SetPrivacyScreen(bool enabled);
+  void SetColorSpace(const gfx::ColorSpace& color_space);
+
+  void set_is_hdr_capable_for_testing(bool value) { is_hdr_capable_ = value; }
 
  private:
+  void CommitGammaCorrection(
+      const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+      const std::vector<display::GammaRampRGBEntry>& gamma_lut);
+
   ScreenManager* screen_manager_;  // Not owned.
 
   int64_t display_id_ = -1;
@@ -64,6 +71,8 @@ class DrmDisplay {
   ScopedDrmConnectorPtr connector_;
   std::vector<drmModeModeInfo> modes_;
   gfx::Point origin_;
+  bool is_hdr_capable_ = false;
+  gfx::ColorSpace current_color_space_;
 
   DISALLOW_COPY_AND_ASSIGN(DrmDisplay);
 };
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_display_unittest.cc b/chromium/ui/ozone/platform/drm/gpu/drm_display_unittest.cc
new file mode 100644
index 00000000000..30e8c7ef8bc
--- /dev/null
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_display_unittest.cc
@@ -0,0 +1,192 @@
+// Copyright 2020 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/ozone/platform/drm/gpu/drm_display.h"
+
+#include <utility>
+
+#include "base/test/task_environment.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/color_space.h"
+#include "ui/gfx/linux/test/mock_gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/hardware_display_plane.h"
+#include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager.h"
+#include "ui/ozone/platform/drm/gpu/mock_drm_device.h"
+#include "ui/ozone/platform/drm/gpu/screen_manager.h"
+
+using ::testing::_;
+using ::testing::SizeIs;
+
+// Verifies that the argument goes from 0 to the maximum uint16_t times |scale|.
+MATCHER_P(MatchesLinearRamp, scale, "") {
+  EXPECT_FALSE(arg.empty());
+
+  EXPECT_EQ(arg.front().r, 0);
+  EXPECT_EQ(arg.front().g, 0);
+  EXPECT_EQ(arg.front().b, 0);
+
+  const uint16_t max_value = std::numeric_limits<uint16_t>::max() * scale;
+
+  const auto middle_element = arg[arg.size() / 2];
+  const uint16_t middle_value = max_value * (arg.size() / 2) / (arg.size() - 1);
+  EXPECT_NEAR(middle_element.r, middle_value, 1);
+  EXPECT_NEAR(middle_element.g, middle_value, 1);
+  EXPECT_NEAR(middle_element.b, middle_value, 1);
+
+  const uint16_t last_value = max_value;
+  EXPECT_EQ(arg.back().r, last_value);
+  EXPECT_EQ(arg.back().g, last_value);
+  EXPECT_EQ(arg.back().b, last_value);
+
+  return true;
+}
+
+namespace ui {
+
+namespace {
+
+class MockHardwareDisplayPlaneManager : public HardwareDisplayPlaneManager {
+ public:
+  explicit MockHardwareDisplayPlaneManager(DrmDevice* drm)
+      : HardwareDisplayPlaneManager(drm) {}
+  ~MockHardwareDisplayPlaneManager() override = default;
+
+  MOCK_METHOD3(SetGammaCorrection,
+               bool(uint32_t crtc_id,
+                    const std::vector<display::GammaRampRGBEntry>& degamma_lut,
+                    const std::vector<display::GammaRampRGBEntry>& gamma_lut));
+
+  bool Modeset(uint32_t crtc_id,
+               uint32_t framebuffer_id,
+               uint32_t connector_id,
+               const drmModeModeInfo& mode,
+               const HardwareDisplayPlaneList& plane_list) override {
+    return false;
+  }
+  bool DisableModeset(uint32_t crtc_id, uint32_t connector) override {
+    return false;
+  }
+  bool Commit(HardwareDisplayPlaneList* plane_list,
+              scoped_refptr<PageFlipRequest> page_flip_request,
+              std::unique_ptr<gfx::GpuFence>* out_fence) override {
+    return false;
+  }
+  bool DisableOverlayPlanes(HardwareDisplayPlaneList* plane_list) override {
+    return false;
+  }
+  bool SetColorCorrectionOnAllCrtcPlanes(
+      uint32_t crtc_id,
+      ScopedDrmColorCtmPtr ctm_blob_data) override {
+    return false;
+  }
+  bool ValidatePrimarySize(const DrmOverlayPlane& primary,
+                           const drmModeModeInfo& mode) override {
+    return false;
+  }
+  void RequestPlanesReadyCallback(
+      DrmOverlayPlaneList planes,
+      base::OnceCallback<void(DrmOverlayPlaneList planes)> callback) override {
+    return;
+  }
+  bool InitializePlanes() override { return false; }
+  bool SetPlaneData(HardwareDisplayPlaneList* plane_list,
+                    HardwareDisplayPlane* hw_plane,
+                    const DrmOverlayPlane& overlay,
+                    uint32_t crtc_id,
+                    const gfx::Rect& src_rect) override {
+    return false;
+  }
+  std::unique_ptr<HardwareDisplayPlane> CreatePlane(
+      uint32_t plane_id) override {
+    return nullptr;
+  }
+  bool IsCompatible(HardwareDisplayPlane* plane,
+                    const DrmOverlayPlane& overlay,
+                    uint32_t crtc_index) const override {
+    return false;
+  }
+  bool CommitColorMatrix(const CrtcProperties& crtc_props) override {
+    return false;
+  }
+  bool CommitGammaCorrection(const CrtcProperties& crtc_props) override {
+    return false;
+  }
+};
+
+}  // namespace
+
+class DrmDisplayTest : public testing::Test {
+ protected:
+  DrmDisplayTest()
+      : mock_drm_device_(base::MakeRefCounted<MockDrmDevice>(
+            std::make_unique<MockGbmDevice>())),
+        drm_display_(&screen_manager_, mock_drm_device_) {}
+
+  MockHardwareDisplayPlaneManager* AddMockHardwareDisplayPlaneManager() {
+    auto mock_hardware_display_plane_manager =
+        std::make_unique<MockHardwareDisplayPlaneManager>(
+            mock_drm_device_.get());
+    MockHardwareDisplayPlaneManager* pointer =
+        mock_hardware_display_plane_manager.get();
+    mock_drm_device_->plane_manager_ =
+        std::move(mock_hardware_display_plane_manager);
+    return pointer;
+  }
+
+  base::test::TaskEnvironment env_;
+  scoped_refptr<DrmDevice> mock_drm_device_;
+  ScreenManager screen_manager_;
+  DrmDisplay drm_display_;
+};
+
+TEST_F(DrmDisplayTest, SetColorSpace) {
+  drm_display_.set_is_hdr_capable_for_testing(true);
+  MockHardwareDisplayPlaneManager* plane_manager =
+      AddMockHardwareDisplayPlaneManager();
+
+  ON_CALL(*plane_manager, SetGammaCorrection(_, SizeIs(0), _))
+      .WillByDefault(::testing::Return(true));
+
+  const auto kHDRColorSpace = gfx::ColorSpace::CreateHDR10();
+  EXPECT_CALL(*plane_manager, SetGammaCorrection(_, SizeIs(0), SizeIs(0)));
+  drm_display_.SetColorSpace(kHDRColorSpace);
+
+  const auto kSDRColorSpace = gfx::ColorSpace::CreateREC709();
+  constexpr float kHDRLevel = 2.0;
+  EXPECT_CALL(
+      *plane_manager,
+      SetGammaCorrection(_, SizeIs(0), MatchesLinearRamp(1.0 / kHDRLevel)));
+  drm_display_.SetColorSpace(kSDRColorSpace);
+}
+
+TEST_F(DrmDisplayTest, SetEmptyGammaCorrectionNonHDRDisplay) {
+  MockHardwareDisplayPlaneManager* plane_manager =
+      AddMockHardwareDisplayPlaneManager();
+
+  ON_CALL(*plane_manager, SetGammaCorrection(_, _, _))
+      .WillByDefault(::testing::Return(true));
+
+  EXPECT_CALL(*plane_manager, SetGammaCorrection(_, SizeIs(0), SizeIs(0)));
+  drm_display_.SetGammaCorrection(std::vector<display::GammaRampRGBEntry>(),
+                                  std::vector<display::GammaRampRGBEntry>());
+}
+
+TEST_F(DrmDisplayTest, SetEmptyGammaCorrectionHDRDisplay) {
+  drm_display_.set_is_hdr_capable_for_testing(true);
+  MockHardwareDisplayPlaneManager* plane_manager =
+      AddMockHardwareDisplayPlaneManager();
+
+  ON_CALL(*plane_manager, SetGammaCorrection(_, _, _))
+      .WillByDefault(::testing::Return(true));
+
+  constexpr float kHDRLevel = 2.0;
+  EXPECT_CALL(
+      *plane_manager,
+      SetGammaCorrection(_, SizeIs(0), MatchesLinearRamp(1.0 / kHDRLevel)));
+  drm_display_.SetGammaCorrection(std::vector<display::GammaRampRGBEntry>(),
+                                  std::vector<display::GammaRampRGBEntry>());
+}
+
+}  // namespace ui
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_framebuffer.cc b/chromium/ui/ozone/platform/drm/gpu/drm_framebuffer.cc
index 772786b42ed..bdf7db0ec19 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_framebuffer.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_framebuffer.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 
+#include "base/logging.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/linux/drm_util_linux.h"
 #include "ui/gfx/linux/gbm_buffer.h"
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.cc b/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.cc
index 74a5f19d91c..e7642e41351 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.cc
@@ -8,6 +8,7 @@
 #include <memory>
 #include <utility>
 
+#include "base/logging.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
@@ -250,6 +251,17 @@ void DrmGpuDisplayManager::SetPrivacyScreen(int64_t display_id, bool enabled) {
   display->SetPrivacyScreen(enabled);
 }
 
+void DrmGpuDisplayManager::SetColorSpace(int64_t crtc_id,
+                                         const gfx::ColorSpace& color_space) {
+  for (const auto& display : displays_) {
+    if (display->crtc() == crtc_id) {
+      display->SetColorSpace(color_space);
+      return;
+    }
+  }
+  LOG(ERROR) << __func__ << " there is no display with CRTC ID " << crtc_id;
+}
+
 DrmDisplay* DrmGpuDisplayManager::FindDisplay(int64_t display_id) {
   for (const auto& display : displays_) {
     if (display->display_id() == display_id)
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h b/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h
index 5efd37fde04..6bc0d2472ea 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h
@@ -21,6 +21,10 @@ class DisplayMode;
 struct GammaRampRGBEntry;
 }
 
+namespace gfx {
+class ColorSpace;
+}
+
 namespace ui {
 
 class DrmDeviceManager;
@@ -61,6 +65,8 @@ class DrmGpuDisplayManager {
       const std::vector<display::GammaRampRGBEntry>& gamma_lut);
   void SetPrivacyScreen(int64_t display_id, bool enabled);
 
+  void SetColorSpace(int64_t crtc_id, const gfx::ColorSpace& color_space);
+
  private:
   DrmDisplay* FindDisplay(int64_t display_id);
 
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_gpu_util.cc b/chromium/ui/ozone/platform/drm/gpu/drm_gpu_util.cc
index bc1ab154808..4e70e45f0c1 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_gpu_util.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_gpu_util.cc
@@ -9,6 +9,7 @@
 #include <xf86drmMode.h>
 
 #include "base/files/scoped_file.h"
+#include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_thread.cc b/chromium/ui/ozone/platform/drm/gpu/drm_thread.cc
index 181fcd86a18..13b3dd7a141 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_thread.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_thread.cc
@@ -5,6 +5,7 @@
 #include "ui/ozone/platform/drm/gpu/drm_thread.h"
 
 #include <gbm.h>
+
 #include <memory>
 #include <utility>
 
@@ -22,6 +23,7 @@
 #include "ui/gfx/linux/gbm_util.h"
 #include "ui/gfx/presentation_feedback.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
+#include "ui/ozone/platform/drm/gpu/crtc_controller.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_dumb_buffer.h"
@@ -108,8 +110,8 @@ void DrmThread::Init() {
   device_manager_ =
       std::make_unique<DrmDeviceManager>(std::move(device_generator_));
   screen_manager_ = std::make_unique<ScreenManager>();
-  display_manager_.reset(
-      new DrmGpuDisplayManager(screen_manager_.get(), device_manager_.get()));
+  display_manager_ = std::make_unique<DrmGpuDisplayManager>(
+      screen_manager_.get(), device_manager_.get());
 
   DCHECK(task_runner())
       << "DrmThread::Init -- thread doesn't have a task_runner";
@@ -276,8 +278,8 @@ void DrmThread::SetCursor(gfx::AcceleratedWidget widget,
                           const gfx::Point& location,
                           int32_t frame_delay_ms) {
   TRACE_EVENT0("drm", "DrmThread::SetCursor");
-  screen_manager_->GetWindow(widget)
-      ->SetCursor(bitmaps, location, frame_delay_ms);
+  screen_manager_->GetWindow(widget)->SetCursor(bitmaps, location,
+                                                frame_delay_ms);
 }
 
 void DrmThread::MoveCursor(gfx::AcceleratedWidget widget,
@@ -324,20 +326,21 @@ void DrmThread::RefreshNativeDisplays(
 }
 
 void DrmThread::ConfigureNativeDisplay(
-    int64_t id,
-    std::unique_ptr<display::DisplayMode> mode,
-    const gfx::Point& origin,
+    const display::DisplayConfigurationParams& display_config_params,
     base::OnceCallback<void(int64_t, bool)> callback) {
   TRACE_EVENT0("drm", "DrmThread::ConfigureNativeDisplay");
-  std::move(callback).Run(
-      id, display_manager_->ConfigureDisplay(id, *mode, origin));
-}
 
-void DrmThread::DisableNativeDisplay(
-    int64_t id,
-    base::OnceCallback<void(int64_t, bool)> callback) {
-  TRACE_EVENT0("drm", "DrmThread::DisableNativeDisplay");
-  std::move(callback).Run(id, display_manager_->DisableDisplay(id));
+  if (display_config_params.mode) {
+    std::move(callback).Run(
+        display_config_params.id,
+        display_manager_->ConfigureDisplay(display_config_params.id,
+                                           *display_config_params.mode.value(),
+                                           display_config_params.origin));
+  } else {
+    std::move(callback).Run(
+        display_config_params.id,
+        display_manager_->DisableDisplay(display_config_params.id));
+  }
 }
 
 void DrmThread::TakeDisplayControl(base::OnceCallback<void(bool)> callback) {
@@ -418,4 +421,17 @@ void DrmThread::ProcessPendingTasks() {
   pending_tasks_.clear();
 }
 
+void DrmThread::SetColorSpace(gfx::AcceleratedWidget widget,
+                              const gfx::ColorSpace& color_space) {
+  DCHECK(screen_manager_->GetWindow(widget));
+  HardwareDisplayController* controller =
+      screen_manager_->GetWindow(widget)->GetController();
+  if (!controller)
+    return;
+
+  const auto& crtc_controllers = controller->crtc_controllers();
+  for (const auto& crtc_controller : crtc_controllers)
+    display_manager_->SetColorSpace(crtc_controller->crtc(), color_space);
+}
+
 }  // namespace ui
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_thread.h b/chromium/ui/ozone/platform/drm/gpu/drm_thread.h
index b4ec4298339..71457f24c99 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_thread.h
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_thread.h
@@ -6,6 +6,7 @@
 #define UI_OZONE_PLATFORM_DRM_GPU_DRM_THREAD_H_
 
 #include <stdint.h>
+
 #include <memory>
 
 #include "base/files/file.h"
@@ -17,6 +18,7 @@
 #include "mojo/public/cpp/bindings/pending_associated_receiver.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/receiver_set.h"
+#include "ui/display/types/display_configuration_params.h"
 #include "ui/gfx/native_pixmap_handle.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/vsync_provider.h"
@@ -32,14 +34,13 @@ class FilePath;
 }
 
 namespace display {
-class DisplayMode;
 struct GammaRampRGBEntry;
-}
+}  // namespace display
 
 namespace gfx {
 class Point;
 class Rect;
-}
+}  // namespace gfx
 
 namespace ui {
 
@@ -107,6 +108,9 @@ class DrmThread : public base::Thread,
   void AddDrmDeviceReceiver(
       mojo::PendingReceiver<ozone::mojom::DrmDevice> receiver);
 
+  void SetColorSpace(gfx::AcceleratedWidget widget,
+                     const gfx::ColorSpace& color_space);
+
   // Verifies if the display controller can successfully scanout the given set
   // of OverlaySurfaceCandidates and return the status associated with each
   // candidate.
@@ -143,13 +147,8 @@ class DrmThread : public base::Thread,
       base::OnceCallback<void(MovableDisplaySnapshots)> callback) override;
   void AddGraphicsDevice(const base::FilePath& path, base::File file) override;
   void RemoveGraphicsDevice(const base::FilePath& path) override;
-  void DisableNativeDisplay(
-      int64_t id,
-      base::OnceCallback<void(int64_t, bool)> callback) override;
   void ConfigureNativeDisplay(
-      int64_t id,
-      std::unique_ptr<display::DisplayMode> mode,
-      const gfx::Point& origin,
+      const display::DisplayConfigurationParams& display_config_params,
       base::OnceCallback<void(int64_t, bool)> callback) override;
   void GetHDCPState(int64_t display_id,
                     base::OnceCallback<void(int64_t, bool, display::HDCPState)>
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.cc b/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.cc
index f94428bf86f..64751f39426 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.cc
@@ -52,4 +52,11 @@ bool DrmWindowProxy::SupportsGpuFences() const {
                           switches::kDisableExplicitDmaFences);
 }
 
+void DrmWindowProxy::SetColorSpace(const gfx::ColorSpace& color_space) const {
+  drm_thread_->task_runner()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&DrmThread::SetColorSpace, base::Unretained(drm_thread_),
+                     widget_, color_space));
+}
+
 }  // namespace ui
diff --git a/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.h b/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.h
index 303051c1c25..8bb036e0ef9 100644
--- a/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.h
+++ b/chromium/ui/ozone/platform/drm/gpu/drm_window_proxy.h
@@ -12,6 +12,10 @@
 #include "ui/gfx/vsync_provider.h"
 #include "ui/ozone/public/swap_completion_callback.h"
 
+namespace gfx {
+class ColorSpace;
+}
+
 namespace ui {
 
 class DrmThread;
@@ -30,6 +34,8 @@ class DrmWindowProxy {
 
   bool SupportsGpuFences() const;
 
+  void SetColorSpace(const gfx::ColorSpace& color_space) const;
+
  private:
   const gfx::AcceleratedWidget widget_;
 
diff --git a/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.cc b/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.cc
index 8c32abbafef..29b76be970e 100644
--- a/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.cc
@@ -79,6 +79,16 @@ bool GbmSurfaceless::ScheduleOverlayPlane(
   return true;
 }
 
+bool GbmSurfaceless::Resize(const gfx::Size& size,
+                            float scale_factor,
+                            const gfx::ColorSpace& color_space,
+                            bool has_alpha) {
+  if (window_)
+    window_->SetColorSpace(color_space);
+
+  return SurfacelessEGL::Resize(size, scale_factor, color_space, has_alpha);
+}
+
 bool GbmSurfaceless::IsOffscreen() {
   return false;
 }
@@ -111,7 +121,8 @@ void GbmSurfaceless::SwapBuffersAsync(
   TRACE_EVENT0("drm", "GbmSurfaceless::SwapBuffersAsync");
   // If last swap failed, don't try to schedule new ones.
   if (!last_swap_buffers_result_) {
-    std::move(completion_callback).Run(gfx::SwapResult::SWAP_FAILED, nullptr);
+    std::move(completion_callback)
+        .Run(gfx::SwapCompletionResult(gfx::SwapResult::SWAP_FAILED));
     // Notify the caller, the buffer is never presented on a screen.
     std::move(presentation_callback).Run(gfx::PresentationFeedback::Failure());
     return;
@@ -230,6 +241,13 @@ void GbmSurfaceless::SubmitFrame() {
   DCHECK(!unsubmitted_frames_.empty());
 
   if (unsubmitted_frames_.front()->ready && !submitted_frame_) {
+    for (auto& overlay : unsubmitted_frames_.front()->overlays) {
+      if (overlay.z_order() == 0 && overlay.gpu_fence()) {
+        submitted_frame_gpu_fence_ = std::make_unique<gfx::GpuFence>(
+            gfx::CloneHandleForIPC(overlay.gpu_fence()->GetGpuFenceHandle()));
+        break;
+      }
+    }
     submitted_frame_ = std::move(unsubmitted_frames_.front());
     unsubmitted_frames_.erase(unsubmitted_frames_.begin());
 
@@ -270,12 +288,19 @@ void GbmSurfaceless::OnSubmission(gfx::SwapResult result,
 }
 
 void GbmSurfaceless::OnPresentation(const gfx::PresentationFeedback& feedback) {
-  // Explicitly destroy overlays to free resources (e.g., fences) early.
+  gfx::PresentationFeedback feedback_copy = feedback;
+
+  if (submitted_frame_gpu_fence_) {
+    feedback_copy.ready_timestamp =
+        submitted_frame_gpu_fence_->GetMaxTimestamp();
+  }
+  submitted_frame_gpu_fence_.reset();
   submitted_frame_->overlays.clear();
 
   gfx::SwapResult result = submitted_frame_->swap_result;
-  std::move(submitted_frame_->completion_callback).Run(result, nullptr);
-  std::move(submitted_frame_->presentation_callback).Run(feedback);
+  std::move(submitted_frame_->completion_callback)
+      .Run(gfx::SwapCompletionResult(result));
+  std::move(submitted_frame_->presentation_callback).Run(feedback_copy);
   submitted_frame_.reset();
 
   if (result == gfx::SwapResult::SWAP_FAILED) {
diff --git a/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.h b/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.h
index 2bfbf347f2e..9b638ef08ff 100644
--- a/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.h
+++ b/chromium/ui/ozone/platform/drm/gpu/gbm_surfaceless.h
@@ -17,6 +17,10 @@
 #include "ui/gl/scoped_binders.h"
 #include "ui/ozone/platform/drm/gpu/drm_overlay_plane.h"
 
+namespace gfx {
+class GpuFence;
+}  // namespace gfx
+
 namespace ui {
 
 class DrmWindowProxy;
@@ -44,6 +48,10 @@ class GbmSurfaceless : public gl::SurfacelessEGL {
                             const gfx::RectF& crop_rect,
                             bool enable_blend,
                             std::unique_ptr<gfx::GpuFence> gpu_fence) override;
+  bool Resize(const gfx::Size& size,
+              float scale_factor,
+              const gfx::ColorSpace& color_space,
+              bool has_alpha) override;
   bool IsOffscreen() override;
   bool SupportsAsyncSwap() override;
   bool SupportsPostSubBuffer() override;
@@ -104,6 +112,7 @@ class GbmSurfaceless : public gl::SurfacelessEGL {
   std::unique_ptr<gfx::VSyncProvider> vsync_provider_;
   std::vector<std::unique_ptr<PendingFrame>> unsubmitted_frames_;
   std::unique_ptr<PendingFrame> submitted_frame_;
+  std::unique_ptr<gfx::GpuFence> submitted_frame_gpu_fence_;
   const bool has_implicit_external_sync_;
   const bool has_image_flush_external_;
   bool last_swap_buffers_result_ = true;
diff --git a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane.cc b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane.cc
index 2d19a1a8b26..6505127b024 100644
--- a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane.cc
@@ -126,11 +126,12 @@ std::vector<uint64_t> HardwareDisplayPlane::ModifiersForFormat(
     uint32_t format) const {
   std::vector<uint64_t> modifiers;
 
-  uint32_t format_index =
-      std::find(supported_formats_.begin(), supported_formats_.end(), format) -
-      supported_formats_.begin();
-  DCHECK_LT(format_index, supported_formats_.size());
+  auto it =
+      std::find(supported_formats_.begin(), supported_formats_.end(), format);
+  if (it == supported_formats_.end())
+    return modifiers;
 
+  uint32_t format_index = it - supported_formats_.begin();
   for (const auto& modifier : supported_format_modifiers_) {
     // modifier.formats is a bitmask of the formats the modifier
     // applies to, starting at format modifier.offset. That is, if bit
diff --git a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.cc b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.cc
index 28d692268d7..1899daf4e7c 100644
--- a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.cc
@@ -4,6 +4,7 @@
 
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.h"
 
+#include "base/logging.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_util.h"
 
diff --git a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager.h b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager.h
index b1070a0d89e..b2443c90b07 100644
--- a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager.h
+++ b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager.h
@@ -84,7 +84,7 @@ class HardwareDisplayPlaneManager {
   void SetBackgroundColor(uint32_t crtc_id, const uint64_t background_color);
 
   // Sets the degamma/gamma luts on the CRTC object with ID |crtc_id|.
-  bool SetGammaCorrection(
+  virtual bool SetGammaCorrection(
       uint32_t crtc_id,
       const std::vector<display::GammaRampRGBEntry>& degamma_lut,
       const std::vector<display::GammaRampRGBEntry>& gamma_lut);
diff --git a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.cc b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.cc
index 4ec9db772db..2bdf60aba9d 100644
--- a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.cc
@@ -12,6 +12,7 @@
 
 #include "base/bind.h"
 #include "base/files/platform_file.h"
+#include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "ui/gfx/gpu_fence.h"
diff --git a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.cc b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.cc
index 4bbd89541aa..91926a0d2b2 100644
--- a/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.cc
@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/task/post_task.h"
 #include "base/task/thread_pool.h"
diff --git a/chromium/ui/ozone/platform/drm/gpu/screen_manager.cc b/chromium/ui/ozone/platform/drm/gpu/screen_manager.cc
index 42473035751..342bad7004f 100644
--- a/chromium/ui/ozone/platform/drm/gpu/screen_manager.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/screen_manager.cc
@@ -9,6 +9,7 @@
 #include <utility>
 
 #include "base/files/platform_file.h"
+#include "base/logging.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "ui/display/types/display_snapshot.h"
diff --git a/chromium/ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.cc b/chromium/ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.cc
index 601cdb36873..e3792ee932d 100644
--- a/chromium/ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.cc
+++ b/chromium/ui/ozone/platform/drm/gpu/vulkan_implementation_gbm.cc
@@ -7,6 +7,7 @@
 #include <memory>
 
 #include "base/files/file_path.h"
+#include "base/logging.h"
 #include "base/native_library.h"
 #include "gpu/vulkan/vulkan_function_pointers.h"
 #include "gpu/vulkan/vulkan_image.h"
diff --git a/chromium/ui/ozone/platform/drm/host/drm_device_handle.cc b/chromium/ui/ozone/platform/drm/host/drm_device_handle.cc
index 7e2a58d4a32..c052a5d1bcb 100644
--- a/chromium/ui/ozone/platform/drm/host/drm_device_handle.cc
+++ b/chromium/ui/ozone/platform/drm/host/drm_device_handle.cc
@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "base/files/file_path.h"
+#include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/threading/scoped_blocking_call.h"
 #include "base/time/time.h"
diff --git a/chromium/ui/ozone/platform/drm/host/drm_display_host.cc b/chromium/ui/ozone/platform/drm/host/drm_display_host.cc
index 3c84a92181f..3da0ad8e912 100644
--- a/chromium/ui/ozone/platform/drm/host/drm_display_host.cc
+++ b/chromium/ui/ozone/platform/drm/host/drm_display_host.cc
@@ -9,7 +9,9 @@
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "ui/display/types/display_configuration_params.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
@@ -44,12 +46,10 @@ void DrmDisplayHost::Configure(const display::DisplayMode* mode,
 
   configure_callback_ = std::move(callback);
   bool status = false;
-  if (mode) {
-    status = sender_->GpuConfigureNativeDisplay(snapshot_->display_id(), *mode,
-                                                origin);
-  } else {
-    status = sender_->GpuDisableNativeDisplay(snapshot_->display_id());
-  }
+
+  display::DisplayConfigurationParams display_config_params(
+      snapshot_->display_id(), origin, mode);
+  status = sender_->GpuConfigureNativeDisplay(display_config_params);
 
   if (!status)
     OnDisplayConfigured(false);
diff --git a/chromium/ui/ozone/platform/drm/host/gpu_thread_adapter.h b/chromium/ui/ozone/platform/drm/host/gpu_thread_adapter.h
index d6c6804a586..8b9b8a39eea 100644
--- a/chromium/ui/ozone/platform/drm/host/gpu_thread_adapter.h
+++ b/chromium/ui/ozone/platform/drm/host/gpu_thread_adapter.h
@@ -6,15 +6,12 @@
 #define UI_OZONE_PLATFORM_DRM_HOST_GPU_THREAD_ADAPTER_H_
 
 #include "base/file_descriptor_posix.h"
+#include "ui/display/types/display_configuration_params.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/native_widget_types.h"
 
-namespace display {
-class DisplayMode;
-}  // namespace display
-
 namespace ui {
 
 class DrmDisplayHostManager;
@@ -46,10 +43,8 @@ class GpuThreadAdapter {
   virtual bool GpuRemoveGraphicsDevice(const base::FilePath& path) = 0;
 
   // Services needed by DrmDisplayHost
-  virtual bool GpuConfigureNativeDisplay(int64_t display_id,
-                                         const display::DisplayMode& pmode,
-                                         const gfx::Point& point) = 0;
-  virtual bool GpuDisableNativeDisplay(int64_t display_id) = 0;
+  virtual bool GpuConfigureNativeDisplay(
+      const display::DisplayConfigurationParams& display_config_params) = 0;
   virtual bool GpuGetHDCPState(int64_t display_id) = 0;
   virtual bool GpuSetHDCPState(int64_t display_id,
                                display::HDCPState state) = 0;
diff --git a/chromium/ui/ozone/platform/drm/host/host_drm_device.cc b/chromium/ui/ozone/platform/drm/host/host_drm_device.cc
index a2ca1364f51..58bd76117d4 100644
--- a/chromium/ui/ozone/platform/drm/host/host_drm_device.cc
+++ b/chromium/ui/ozone/platform/drm/host/host_drm_device.cc
@@ -128,36 +128,21 @@ bool HostDrmDevice::GpuRefreshNativeDisplays() {
   return true;
 }
 
-bool HostDrmDevice::GpuConfigureNativeDisplay(int64_t id,
-                                              const display::DisplayMode& pmode,
-                                              const gfx::Point& origin) {
+bool HostDrmDevice::GpuConfigureNativeDisplay(
+    const display::DisplayConfigurationParams& display_config_params) {
   DCHECK_CALLED_ON_VALID_THREAD(on_ui_thread_);
   if (!IsConnected())
     return false;
 
-  auto mode = std::make_unique<display::DisplayMode>(
-      pmode.size(), pmode.is_interlaced(), pmode.refresh_rate());
   auto callback =
       base::BindOnce(&HostDrmDevice::GpuConfigureNativeDisplayCallback, this);
 
-  drm_device_->ConfigureNativeDisplay(id, std::move(mode), origin,
+  drm_device_->ConfigureNativeDisplay(display_config_params,
                                       std::move(callback));
 
   return true;
 }
 
-bool HostDrmDevice::GpuDisableNativeDisplay(int64_t id) {
-  DCHECK_CALLED_ON_VALID_THREAD(on_ui_thread_);
-  if (!IsConnected())
-    return false;
-  auto callback =
-      base::BindOnce(&HostDrmDevice::GpuDisableNativeDisplayCallback, this);
-
-  drm_device_->DisableNativeDisplay(id, std::move(callback));
-
-  return true;
-}
-
 bool HostDrmDevice::GpuTakeDisplayControl() {
   DCHECK_CALLED_ON_VALID_THREAD(on_ui_thread_);
   if (!IsConnected())
@@ -278,12 +263,6 @@ void HostDrmDevice::GpuRefreshNativeDisplaysCallback(
   display_manager_->GpuHasUpdatedNativeDisplays(std::move(displays));
 }
 
-void HostDrmDevice::GpuDisableNativeDisplayCallback(int64_t display_id,
-                                                    bool success) const {
-  DCHECK_CALLED_ON_VALID_THREAD(on_ui_thread_);
-  display_manager_->GpuConfiguredDisplay(display_id, success);
-}
-
 void HostDrmDevice::GpuTakeDisplayControlCallback(bool success) const {
   DCHECK_CALLED_ON_VALID_THREAD(on_ui_thread_);
   display_manager_->GpuTookDisplayControl(success);
diff --git a/chromium/ui/ozone/platform/drm/host/host_drm_device.h b/chromium/ui/ozone/platform/drm/host/host_drm_device.h
index fbe3723e419..a21505193c6 100644
--- a/chromium/ui/ozone/platform/drm/host/host_drm_device.h
+++ b/chromium/ui/ozone/platform/drm/host/host_drm_device.h
@@ -65,10 +65,8 @@ class HostDrmDevice : public base::RefCountedThreadSafe<HostDrmDevice>,
   bool GpuRemoveGraphicsDevice(const base::FilePath& path) override;
 
   // Services needed by DrmDisplayHost
-  bool GpuConfigureNativeDisplay(int64_t display_id,
-                                 const display::DisplayMode& pmode,
-                                 const gfx::Point& point) override;
-  bool GpuDisableNativeDisplay(int64_t display_id) override;
+  bool GpuConfigureNativeDisplay(const display::DisplayConfigurationParams&
+                                     display_config_params) override;
   bool GpuGetHDCPState(int64_t display_id) override;
   bool GpuSetHDCPState(int64_t display_id, display::HDCPState state) override;
   bool GpuSetColorMatrix(int64_t display_id,
@@ -98,7 +96,6 @@ class HostDrmDevice : public base::RefCountedThreadSafe<HostDrmDevice>,
                                          bool success) const;
 
   void GpuRefreshNativeDisplaysCallback(MovableDisplaySnapshots displays) const;
-  void GpuDisableNativeDisplayCallback(int64_t display_id, bool success) const;
   void GpuTakeDisplayControlCallback(bool success) const;
   void GpuRelinquishDisplayControlCallback(bool success) const;
   void GpuGetHDCPStateCallback(int64_t display_id,
diff --git a/chromium/ui/ozone/platform/drm/ozone_platform_gbm.cc b/chromium/ui/ozone/platform/drm/ozone_platform_gbm.cc
index 23786834484..9e0cc71662e 100644
--- a/chromium/ui/ozone/platform/drm/ozone_platform_gbm.cc
+++ b/chromium/ui/ozone/platform/drm/ozone_platform_gbm.cc
@@ -21,6 +21,7 @@
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "ui/base/buildflags.h"
+#include "ui/base/cursor/cursor_factory.h"
 #include "ui/base/cursor/ozone/bitmap_cursor_factory_ozone.h"
 #include "ui/events/ozone/device/device_manager.h"
 #include "ui/events/ozone/evdev/event_factory_evdev.h"
@@ -43,7 +44,6 @@
 #include "ui/ozone/platform/drm/host/drm_window_host.h"
 #include "ui/ozone/platform/drm/host/drm_window_host_manager.h"
 #include "ui/ozone/platform/drm/host/host_drm_device.h"
-#include "ui/ozone/public/cursor_factory_ozone.h"
 #include "ui/ozone/public/gpu_platform_support_host.h"
 #include "ui/ozone/public/mojom/drm_device.mojom.h"
 #include "ui/ozone/public/ozone_platform.h"
@@ -80,9 +80,7 @@ class OzonePlatformGbm : public OzonePlatform {
   OverlayManagerOzone* GetOverlayManager() override {
     return overlay_manager_.get();
   }
-  CursorFactoryOzone* GetCursorFactoryOzone() override {
-    return cursor_factory_ozone_.get();
-  }
+  CursorFactory* GetCursorFactory() override { return cursor_factory_.get(); }
   InputController* GetInputController() override {
     return event_factory_ozone_->input_controller();
   }
@@ -202,7 +200,7 @@ class OzonePlatformGbm : public OzonePlatform {
     display_manager_ = std::make_unique<DrmDisplayHostManager>(
         adapter, device_manager_.get(), &host_properties_,
         event_factory_ozone_->input_controller());
-    cursor_factory_ozone_ = std::make_unique<BitmapCursorFactoryOzone>();
+    cursor_factory_ = std::make_unique<BitmapCursorFactoryOzone>();
 
     host_drm_device_->SetDisplayManager(display_manager_.get());
   }
@@ -307,7 +305,7 @@ class OzonePlatformGbm : public OzonePlatform {
   scoped_refptr<HostDrmDevice> host_drm_device_;
   base::PlatformThreadRef host_thread_;
   std::unique_ptr<DeviceManager> device_manager_;
-  std::unique_ptr<BitmapCursorFactoryOzone> cursor_factory_ozone_;
+  std::unique_ptr<CursorFactory> cursor_factory_;
   std::unique_ptr<DrmWindowHostManager> window_manager_;
   std::unique_ptr<DrmCursor> cursor_;
   std::unique_ptr<EventFactoryEvdev> event_factory_ozone_;