ozone/drm: Use DrmWrapper in DrmGpuDisplayManager and drm/common

This CL modifies all utility functions in ui/ozone/platform/drm/common
to utilized DrmWrapper instead DRM FDs directly.

In addition, this CL updates DrmGpuDisplayManager in a similar way.
Specifically, its call into GetDisplayInfosAndUpdateCrtcs() and
CreateDisplaySnapshot(), which were the main blocker in testing
DrmDisplay.

Bug: b:261628741
Test: display_unittests && ozone_unittests
Change-Id: Ia6031c227597712a2e5ac305d8ba1fdd1d68477d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4264742
Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Commit-Queue: Gil Dekel <gildekel@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1107090}

ui/ozone/platform/drm/common/drm_util.h

@@ -14,13 +14,12 @@
 #include <utility>
 #include <vector>
 
-#include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/notreached.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_snapshot.h"
-#include "ui/ozone/platform/drm/common/display_types.h"
+#include "ui/ozone/platform/drm/common/drm_wrapper.h"
 #include "ui/ozone/platform/drm/common/scoped_drm_types.h"
 
 typedef struct _drmModeModeInfo drmModeModeInfo;
@@ -115,10 +114,11 @@ using HardwareDisplayControllerInfoList =
 // TODO(markyacoub): Create unit tests that tests the different bits and pieces
 // that this function goes through.
 std::pair<HardwareDisplayControllerInfoList, std::vector<uint32_t>>
-GetDisplayInfosAndInvalidCrtcs(int fd);
+GetDisplayInfosAndInvalidCrtcs(const DrmWrapper& drm);
 
 // Returns the display infos parsed in |GetDisplayInfosAndInvalidCrtcs|
-HardwareDisplayControllerInfoList GetAvailableDisplayControllerInfos(int fd);
+HardwareDisplayControllerInfoList GetAvailableDisplayControllerInfos(
+    const DrmWrapper& drm);
 
 bool SameMode(const drmModeModeInfo& lhs, const drmModeModeInfo& rhs);
 
@@ -134,25 +134,24 @@ display::DisplaySnapshot::DisplayModeList ExtractDisplayModes(
     const display::DisplayMode** out_current_mode,
     const display::DisplayMode** out_native_mode);
 
-// |info| provides the DRM information related to the display, |fd| is the
-// connection to the DRM device.
+// |info| provides the DRM information related to the display, |drm| is the
+// access point to the DRM device to which |info| is related to.
 std::unique_ptr<display::DisplaySnapshot> CreateDisplaySnapshot(
+    const DrmWrapper& drm,
     HardwareDisplayControllerInfo* info,
-    int fd,
-    const base::FilePath& sys_path,
     uint8_t device_index,
     const gfx::Point& origin,
     const display::DrmFormatsAndModifiers& drm_formats_and_modifiers);
 
 int GetFourCCFormatForOpaqueFramebuffer(gfx::BufferFormat format);
 
-gfx::Size GetMaximumCursorSize(int fd);
+gfx::Size GetMaximumCursorSize(const DrmWrapper& drm);
 
-ScopedDrmPropertyPtr FindDrmProperty(int fd,
+ScopedDrmPropertyPtr FindDrmProperty(const DrmWrapper& drm,
                                      drmModeObjectProperties* properties,
                                      const char* name);
 
-bool HasColorCorrectionMatrix(int fd, drmModeCrtc* crtc);
+bool HasColorCorrectionMatrix(const DrmWrapper& drm, drmModeCrtc* crtc);
 
 bool MatchMode(const display::DisplayMode& display_mode,
                const drmModeModeInfo& m);
@@ -163,15 +162,17 @@ float ModeRefreshRate(const drmModeModeInfo& mode);
 
 bool ModeIsInterlaced(const drmModeModeInfo& mode);
 
-bool IsVrrCapable(int fd, drmModeConnector* connector);
+bool IsVrrCapable(const DrmWrapper& drm, drmModeConnector* connector);
 
-bool IsVrrEnabled(int fd, drmModeCrtc* crtc);
+bool IsVrrEnabled(const DrmWrapper& drm, drmModeCrtc* crtc);
 
 display::VariableRefreshRateState GetVariableRefreshRateState(
-    int fd,
+    const DrmWrapper& drm,
     HardwareDisplayControllerInfo* info);
 
-uint64_t GetEnumValueForName(int fd, int property_id, const char* str);
+uint64_t GetEnumValueForName(const DrmWrapper& drm,
+                             int property_id,
+                             const char* str);
 
 std::vector<uint64_t> ParsePathBlob(const drmModePropertyBlobRes& path_blob);
 

ui/ozone/platform/drm/common/drm_wrapper.cc

@@ -253,6 +253,16 @@ bool DrmWrapper::CloseBufferHandle(uint32_t handle) {
   return !drmIoctl(drm_fd_.get(), DRM_IOCTL_GEM_CLOSE, &close_request);
 }
 
+/**********
+ * Encoders
+ **********/
+
+ScopedDrmEncoderPtr DrmWrapper::GetEncoder(uint32_t encoder_id) const {
+  DCHECK(drm_fd_.is_valid());
+  TRACE_EVENT1("drm", "DrmWrapper::GetEncoder", "encoder", encoder_id);
+  return ScopedDrmEncoderPtr(drmModeGetEncoder(drm_fd_.get(), encoder_id));
+}
+
 /**************
  * Framebuffers
  **************/
@@ -471,7 +481,14 @@ void DrmWrapper::WriteIntoTrace(perfetto::TracedDictionary dict) const {
 }
 
 absl::optional<std::string> DrmWrapper::GetDriverName() const {
-  return GetDrmDriverNameFromFd(drm_fd_.get());
+  DCHECK(drm_fd_.is_valid());
+  ScopedDrmVersionPtr version(drmGetVersion(drm_fd_.get()));
+  if (!version) {
+    LOG(ERROR) << "Failed to query DRM version";
+    return absl::nullopt;
+  }
+
+  return std::string(version->name, version->name_len);
 }
 
 base::ScopedFD DrmWrapper::ToScopedFD(std::unique_ptr<DrmWrapper> drm) {

ui/ozone/platform/drm/common/drm_wrapper.h

@@ -146,6 +146,13 @@ class DrmWrapper {
 
   virtual bool CloseBufferHandle(uint32_t handle);
 
+  /**********
+   * Encoders
+   **********/
+
+  // Returns the encoder properties for |encoder_id|.
+  virtual ScopedDrmEncoderPtr GetEncoder(uint32_t encoder_id) const;
+
   /**************
    * Framebuffers
    **************/
@@ -259,7 +266,6 @@ class DrmWrapper {
   static base::ScopedFD ToScopedFD(std::unique_ptr<DrmWrapper> drm);
 
   base::FilePath device_path() const { return device_path_; }
-  int get_fd() const { return drm_fd_.get(); }
   bool allow_addfb2_modifiers() const { return allow_addfb2_modifiers_; }
   int modeset_sequence_id() const { return modeset_sequence_id_; }
   bool is_atomic() const { return is_atomic_; }

ui/ozone/platform/drm/gpu/drm_gpu_display_manager.cc

@@ -19,7 +19,6 @@
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
-#include "ui/gfx/linux/drm_util_linux.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_display.h"
@@ -149,7 +148,7 @@ MovableDisplaySnapshots DrmGpuDisplayManager::GetDisplays() {
     // Receiving a signal that DRM state was updated. Need to reset the plane
     // manager's resource cache since IDs may have changed.
     drm->plane_manager()->ResetConnectorsCache(drm->GetResources());
-    auto display_infos = GetDisplayInfosAndUpdateCrtcs(drm->get_fd());
+    auto display_infos = GetDisplayInfosAndUpdateCrtcs(*drm);
     for (const auto& display_info : display_infos) {
       auto it = base::ranges::find_if(
           old_displays,
@@ -175,10 +174,8 @@ MovableDisplaySnapshots DrmGpuDisplayManager::GetDisplays() {
       // Create the new DisplaySnapshot and resolve display ID collisions.
       std::unique_ptr<display::DisplaySnapshot> current_display_snapshot =
           CreateDisplaySnapshot(
-              display_info.get(), current_drm_display->drm()->get_fd(),
-              current_drm_display->drm()->device_path(),
-              static_cast<uint8_t>(device_index), current_drm_display->origin(),
-              drm_formats_and_modifiers);
+              *drm, display_info.get(), static_cast<uint8_t>(device_index),
+              current_drm_display->origin(), drm_formats_and_modifiers);
 
       const auto colliding_display_snapshot_iter = edid_id_collision_map.find(
           current_display_snapshot->edid_display_id());

ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h

@@ -12,8 +12,6 @@
 #include "base/functional/callback.h"
 #include "ui/display/types/display_configuration_params.h"
 #include "ui/display/types/display_constants.h"
-#include "ui/gfx/geometry/point.h"
-#include "ui/gfx/native_widget_types.h"
 #include "ui/ozone/platform/drm/common/display_types.h"
 
 using drmModeModeInfo = struct _drmModeModeInfo;

ui/ozone/platform/drm/gpu/drm_gpu_util.cc

@@ -120,13 +120,14 @@ std::vector<display::GammaRampRGBEntry> ResampleLut(
   return result;
 }
 
-HardwareDisplayControllerInfoList GetDisplayInfosAndUpdateCrtcs(int fd) {
-  auto [displays, invalid_crtcs] = GetDisplayInfosAndInvalidCrtcs(fd);
+HardwareDisplayControllerInfoList GetDisplayInfosAndUpdateCrtcs(
+    DrmWrapper& drm) {
+  auto [displays, invalid_crtcs] = GetDisplayInfosAndInvalidCrtcs(drm);
   // Disable invalid CRTCs to allow the preferred CRTCs to be enabled later
   // instead.
   for (uint32_t crtc : invalid_crtcs) {
-    drmModeSetCrtc(fd, crtc, 0, 0, 0, nullptr, 0, nullptr);
-    VLOG(1) << "Disabled unpreferred CRTC " << crtc;
+    drm.DisableCrtc(crtc);
+    VLOG(1) << "Disabled undesired CRTC " << crtc;
   }
   return std::move(displays);
 }

ui/ozone/platform/drm/gpu/drm_gpu_util.h

@@ -41,7 +41,8 @@ std::vector<display::GammaRampRGBEntry> ResampleLut(
 // Returns the display infos parsed in
 // |GetDisplayInfosAndInvalidCrtcs| and disables the invalid CRTCs
 // that weren't picked as preferred CRTCs.
-HardwareDisplayControllerInfoList GetDisplayInfosAndUpdateCrtcs(int fd);
+HardwareDisplayControllerInfoList GetDisplayInfosAndUpdateCrtcs(
+    DrmWrapper& drm);
 
 void DrmWriteIntoTraceHelper(const drmModeModeInfo& mode_info,
                              perfetto::TracedValue context);

ui/ozone/platform/drm/gpu/hardware_display_controller.cc

@@ -507,7 +507,7 @@ void HardwareDisplayController::OnModesetComplete(
 
 void HardwareDisplayController::AllocateCursorBuffers() {
   TRACE_EVENT0("drm", "HDC::AllocateCursorBuffers");
-  gfx::Size max_cursor_size = GetMaximumCursorSize(GetDrmDevice()->get_fd());
+  gfx::Size max_cursor_size = GetMaximumCursorSize(*GetDrmDevice());
   SkImageInfo info = SkImageInfo::MakeN32Premul(max_cursor_size.width(),
                                                 max_cursor_size.height());
   for (size_t i = 0; i < std::size(cursor_buffers_); ++i) {

ui/ozone/platform/drm/gpu/hardware_display_plane.cc

@@ -113,11 +113,10 @@ bool HardwareDisplayPlane::Initialize(DrmDevice* drm) {
     type_ = properties_.type.value;
 
   if (properties_.plane_color_encoding.id) {
-    color_encoding_bt601_ =
-        GetEnumValueForName(drm->get_fd(), properties_.plane_color_encoding.id,
-                            "ITU-R BT.601 YCbCr");
+    color_encoding_bt601_ = GetEnumValueForName(
+        *drm, properties_.plane_color_encoding.id, "ITU-R BT.601 YCbCr");
     color_range_limited_ = GetEnumValueForName(
-        drm->get_fd(), properties_.plane_color_range.id, "YCbCr limited range");
+        *drm, properties_.plane_color_range.id, "YCbCr limited range");
   }
 
   VLOG(3) << "Initialized plane=" << id_

ui/ozone/platform/drm/gpu/hardware_display_plane_manager.cc

@@ -449,8 +449,7 @@ void HardwareDisplayPlaneManager::DisableConnectedConnectorsToCrtcs(
     // encoder).
     if (connector->encoder_id &&
         connector->connection == DRM_MODE_DISCONNECTED) {
-      ScopedDrmEncoderPtr encoder(
-          drmModeGetEncoder(drm_->get_fd(), connector->encoder_id));
+      ScopedDrmEncoderPtr encoder = drm_->GetEncoder(connector->encoder_id);
       if (encoder)
         drm_->DisableCrtc(encoder->crtc_id);
     }

ui/ozone/platform/drm/host/drm_display_host_manager.cc

@@ -14,7 +14,6 @@
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/functional/bind.h"
-#include "base/ranges/algorithm.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task/single_thread_task_runner.h"
@@ -280,15 +279,13 @@ DrmDisplayHostManager::DrmDisplayHostManager(
   proxy_->RegisterHandlerForDrmDisplayHostManager(this);
   proxy_->AddGpuThreadObserver(this);
 
-  auto display_infos =
-      GetAvailableDisplayControllerInfos(primary_drm_device_->get_fd());
+  auto display_infos = GetAvailableDisplayControllerInfos(*primary_drm_device_);
   has_dummy_display_ = !display_infos.empty();
   MapEdidIdToDisplaySnapshot edid_id_collision_map;
   for (auto& display_info : display_infos) {
     // Create a dummy DisplaySnapshot and resolve display ID collisions.
     std::unique_ptr<display::DisplaySnapshot> current_display_snapshot =
-        CreateDisplaySnapshot(display_info.get(), primary_drm_device_->get_fd(),
-                              primary_drm_device_->device_path(), 0,
+        CreateDisplaySnapshot(*primary_drm_device_, display_info.get(), 0,
                               gfx::Point(), display::DrmFormatsAndModifiers());
 
     const auto colliding_display_snapshot_iter =