ozone: drm: Merge GbmDevice and GbmDeviceLinux

Currently GbmDevice is-a DrmDevice is-a GbmDeviceLinux. Instead, put a
GbmDevice inside DrmDevice. This also removes a bunch of unnecessary
casts.

Bug: 869206

Change-Id: If7ea97f495081ebf4d05f44af2bd78c3357e23da
Reviewed-on: https://chromium-review.googlesource.com/1157254Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Commit-Queue: Michael Spang <spang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579887}

ui/ozone/common/linux/BUILD.gn

@@ -13,8 +13,8 @@ source_set("linux") {
     "drm_util_linux.h",
     "gbm_buffer.cc",
     "gbm_buffer.h",
-    "gbm_device_linux.cc",
-    "gbm_device_linux.h",
+    "gbm_device.cc",
+    "gbm_device.h",
   ]
 
   deps = [

ui/ozone/common/linux/gbm_device_linux.cc → ui/ozone/common/linux/gbm_device.cc

@@ -2,20 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ui/ozone/common/linux/gbm_device_linux.h"
+#include "ui/ozone/common/linux/gbm_device.h"
 
 #include <gbm.h>
 
 namespace ui {
 
-GbmDeviceLinux::GbmDeviceLinux() {}
+GbmDevice::GbmDevice() {}
 
-GbmDeviceLinux::~GbmDeviceLinux() {
-  if (device_)
+GbmDevice::~GbmDevice() {
+  if (device_) {
     gbm_device_destroy(device_);
+    device_ = nullptr;
+  }
 }
 
-bool GbmDeviceLinux::InitializeGbmDevice(int fd) {
+bool GbmDevice::Initialize(int fd) {
+  DCHECK(!device_);
   device_ = gbm_create_device(fd);
   return !!device_;
 }

ui/ozone/common/linux/gbm_device_linux.h → ui/ozone/common/linux/gbm_device.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef UI_OZONE_COMMON_LINUX_GBM_DEVICE_LINUX_H_
-#define UI_OZONE_COMMON_LINUX_GBM_DEVICE_LINUX_H_
+#ifndef UI_OZONE_COMMON_LINUX_GBM_DEVICE_H_
+#define UI_OZONE_COMMON_LINUX_GBM_DEVICE_H_
 
 #include "base/files/file.h"
 #include "base/macros.h"
@@ -12,21 +12,21 @@ struct gbm_device;
 
 namespace ui {
 
-class GbmDeviceLinux {
+class GbmDevice {
  public:
-  GbmDeviceLinux();
-  virtual ~GbmDeviceLinux();
+  GbmDevice();
+  ~GbmDevice();
 
   gbm_device* device() const { return device_; }
 
-  bool InitializeGbmDevice(int fd);
+  bool Initialize(int fd);
 
  private:
   gbm_device* device_ = nullptr;
 
-  DISALLOW_COPY_AND_ASSIGN(GbmDeviceLinux);
+  DISALLOW_COPY_AND_ASSIGN(GbmDevice);
 };
 
 }  // namespace ui
 
-#endif  // UI_OZONE_COMMON_LINUX_GBM_DEVICE_LINUX_H_
+#endif  // UI_OZONE_COMMON_LINUX_GBM_DEVICE_H_

ui/ozone/platform/drm/BUILD.gn

@@ -62,8 +62,6 @@ source_set("gbm") {
     "gpu/drm_window_proxy.h",
     "gpu/gbm_pixmap.cc",
     "gpu/gbm_pixmap.h",
-    "gpu/gbm_device.cc",
-    "gpu/gbm_device.h",
     "gpu/gbm_overlay_surface.cc",
     "gpu/gbm_overlay_surface.h",
     "gpu/gbm_surface.cc",

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

@@ -275,6 +275,11 @@ bool DrmDevice::Initialize() {
   watcher_.reset(
       new IOWatcher(file_.GetPlatformFile(), page_flip_manager_.get()));
 
+  if (!gbm_.Initialize(file_.GetPlatformFile())) {
+    PLOG(ERROR) << "Unable to initialize GBM for " << device_path_.value();
+    return false;
+  }
+
   return true;
 }
 

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

@@ -19,7 +19,7 @@
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/overlay_transform.h"
-#include "ui/ozone/common/linux/gbm_device_linux.h"
+#include "ui/ozone/common/linux/gbm_device.h"
 #include "ui/ozone/platform/drm/common/scoped_drm_types.h"
 #include "ui/ozone/platform/drm/gpu/page_flip_request.h"
 
@@ -56,8 +56,7 @@ using ScopedDrmPropertyBlob = std::unique_ptr<DrmPropertyBlobMetadata>;
 // Wraps DRM calls into a nice interface. Used to provide different
 // implementations of the DRM calls. For the actual implementation the DRM API
 // would be called. In unit tests this interface would be stubbed.
-class DrmDevice : public GbmDeviceLinux,
-                  public base::RefCountedThreadSafe<DrmDevice> {
+class DrmDevice : public base::RefCountedThreadSafe<DrmDevice> {
  public:
   using PageFlipCallback =
       base::OnceCallback<void(unsigned int /* frame */,
@@ -247,10 +246,12 @@ class DrmDevice : public GbmDeviceLinux,
 
   HardwareDisplayPlaneManager* plane_manager() { return plane_manager_.get(); }
 
+  gbm_device* gbm_device() const { return gbm_.device(); }
+
  protected:
   friend class base::RefCountedThreadSafe<DrmDevice>;
 
-  ~DrmDevice() override;
+  virtual ~DrmDevice();
 
   std::unique_ptr<HardwareDisplayPlaneManager> plane_manager_;
 
@@ -258,6 +259,8 @@ class DrmDevice : public GbmDeviceLinux,
   class IOWatcher;
   class PageFlipManager;
 
+  GbmDevice gbm_;
+
   // Path to the DRM device (in sysfs).
   const base::FilePath device_path_;
 

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

@@ -16,6 +16,7 @@
 #include "ui/display/types/display_snapshot.h"
 #include "ui/gfx/presentation_feedback.h"
 #include "ui/ozone/common/linux/drm_util_linux.h"
+#include "ui/ozone/common/linux/gbm_device.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
@@ -24,7 +25,6 @@
 #include "ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
-#include "ui/ozone/platform/drm/gpu/gbm_device.h"
 #include "ui/ozone/platform/drm/gpu/gbm_pixmap.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
 #include "ui/ozone/platform/drm/gpu/proxy_helpers.h"
@@ -36,7 +36,7 @@ namespace ui {
 namespace {
 
 scoped_refptr<DrmFramebuffer> AddFramebuffersForBo(
-    const scoped_refptr<GbmDevice>& gbm,
+    const scoped_refptr<DrmDevice>& drm,
     gbm_bo* bo,
     uint32_t format,
     uint64_t format_modifier) {
@@ -57,11 +57,11 @@ scoped_refptr<DrmFramebuffer> AddFramebuffersForBo(
   // a bo with modifiers, otherwise, we rely on the "no modifiers"
   // behavior doing the right thing.
   params.flags = 0;
-  if (gbm->allow_addfb2_modifiers() &&
+  if (drm->allow_addfb2_modifiers() &&
       params.modifier != DRM_FORMAT_MOD_INVALID)
     params.flags |= DRM_MODE_FB_MODIFIERS;
 
-  return DrmFramebuffer::AddFramebuffer(gbm.get(), params);
+  return DrmFramebuffer::AddFramebuffer(drm, params);
 }
 
 uint32_t BufferUsageToGbmFlags(gfx::BufferUsage usage) {
@@ -88,7 +88,7 @@ uint32_t BufferUsageToGbmFlags(gfx::BufferUsage usage) {
   }
 }
 
-void CreateBufferWithGbmFlags(const scoped_refptr<GbmDevice>& gbm,
+void CreateBufferWithGbmFlags(const scoped_refptr<DrmDevice>& drm,
                               uint32_t fourcc_format,
                               const gfx::Size& size,
                               uint32_t flags,
@@ -97,16 +97,17 @@ void CreateBufferWithGbmFlags(const scoped_refptr<GbmDevice>& gbm,
                               scoped_refptr<DrmFramebuffer>* out_framebuffer) {
   std::unique_ptr<GbmBuffer> buffer;
   if (modifiers.empty())
-    buffer = GbmBuffer::CreateBuffer(gbm->device(), fourcc_format, size, flags);
+    buffer =
+        GbmBuffer::CreateBuffer(drm->gbm_device(), fourcc_format, size, flags);
   else
-    buffer = GbmBuffer::CreateBufferWithModifiers(gbm->device(), fourcc_format,
-                                                  size, flags, modifiers);
+    buffer = GbmBuffer::CreateBufferWithModifiers(
+        drm->gbm_device(), fourcc_format, size, flags, modifiers);
   if (!buffer)
     return;
 
   scoped_refptr<DrmFramebuffer> framebuffer;
   if (flags & GBM_BO_USE_SCANOUT) {
-    framebuffer = AddFramebuffersForBo(gbm, buffer->bo(), buffer->format(),
+    framebuffer = AddFramebuffersForBo(drm, buffer->bo(), buffer->format(),
                                        buffer->format_modifier());
     if (!framebuffer)
       return;
@@ -126,21 +127,20 @@ class GbmBufferGenerator : public DrmFramebufferGenerator {
                                        uint32_t format,
                                        const std::vector<uint64_t>& modifiers,
                                        const gfx::Size& size) override {
-    scoped_refptr<GbmDevice> gbm(static_cast<GbmDevice*>(drm.get()));
     std::unique_ptr<GbmBuffer> buffer;
 
     if (modifiers.size() > 0) {
       buffer = GbmBuffer::CreateBufferWithModifiers(
-          gbm->device(), format, size, GBM_BO_USE_SCANOUT, modifiers);
+          drm->gbm_device(), format, size, GBM_BO_USE_SCANOUT, modifiers);
     } else {
-      buffer = GbmBuffer::CreateBuffer(gbm->device(), format, size,
+      buffer = GbmBuffer::CreateBuffer(drm->gbm_device(), format, size,
                                        GBM_BO_USE_SCANOUT);
     }
 
     if (!buffer)
       return nullptr;
 
-    return AddFramebuffersForBo(gbm, buffer->bo(), buffer->format(),
+    return AddFramebuffersForBo(drm, buffer->bo(), buffer->format(),
                                 buffer->format_modifier());
   }
 
@@ -157,12 +157,11 @@ class GbmDeviceGenerator : public DrmDeviceGenerator {
   scoped_refptr<DrmDevice> CreateDevice(const base::FilePath& path,
                                         base::File file,
                                         bool is_primary_device) override {
-    scoped_refptr<DrmDevice> drm =
-        new GbmDevice(path, std::move(file), is_primary_device);
-    if (drm->Initialize())
-      return drm;
-
-    return nullptr;
+    auto drm = base::MakeRefCounted<DrmDevice>(path, std::move(file),
+                                               is_primary_device);
+    if (!drm->Initialize())
+      return nullptr;
+    return drm;
   }
 
  private:
@@ -212,9 +211,8 @@ void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
                              uint32_t client_flags,
                              std::unique_ptr<GbmBuffer>* buffer,
                              scoped_refptr<DrmFramebuffer>* framebuffer) {
-  scoped_refptr<GbmDevice> gbm =
-      static_cast<GbmDevice*>(device_manager_->GetDrmDevice(widget).get());
-  DCHECK(gbm);
+  scoped_refptr<ui::DrmDevice> drm = device_manager_->GetDrmDevice(widget);
+  DCHECK(drm);
 
   DrmWindow* window = screen_manager_->GetWindow(widget);
   uint32_t flags = BufferUsageToGbmFlags(usage);
@@ -228,7 +226,7 @@ void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
     modifiers = window->GetController()->GetFormatModifiers(fourcc_format);
   }
 
-  CreateBufferWithGbmFlags(gbm, fourcc_format, size, flags, modifiers, buffer,
+  CreateBufferWithGbmFlags(drm, fourcc_format, size, flags, modifiers, buffer,
                            framebuffer);
 
   // NOTE: BufferUsage::SCANOUT is used to create buffers that will be
@@ -237,7 +235,7 @@ void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
   // buffer in that case.
   if (!*buffer && usage != gfx::BufferUsage::SCANOUT) {
     flags &= ~GBM_BO_USE_SCANOUT;
-    CreateBufferWithGbmFlags(gbm, fourcc_format, size, flags, modifiers, buffer,
+    CreateBufferWithGbmFlags(drm, fourcc_format, size, flags, modifiers, buffer,
                              framebuffer);
   }
 }
@@ -250,19 +248,18 @@ void DrmThread::CreateBufferFromFds(
     const std::vector<gfx::NativePixmapPlane>& planes,
     std::unique_ptr<GbmBuffer>* out_buffer,
     scoped_refptr<DrmFramebuffer>* out_framebuffer) {
-  scoped_refptr<GbmDevice> gbm =
-      static_cast<GbmDevice*>(device_manager_->GetDrmDevice(widget).get());
-  DCHECK(gbm);
+  scoped_refptr<ui::DrmDevice> drm = device_manager_->GetDrmDevice(widget);
+  DCHECK(drm);
 
   std::unique_ptr<GbmBuffer> buffer = GbmBuffer::CreateBufferFromFds(
-      gbm->device(), ui::GetFourCCFormatFromBufferFormat(format), size,
+      drm->gbm_device(), ui::GetFourCCFormatFromBufferFormat(format), size,
       std::move(fds), planes);
   if (!buffer)
     return;
 
   scoped_refptr<DrmFramebuffer> framebuffer;
   if (buffer->flags() & GBM_BO_USE_SCANOUT) {
-    framebuffer = AddFramebuffersForBo(gbm, buffer->bo(), buffer->format(),
+    framebuffer = AddFramebuffersForBo(drm, buffer->bo(), buffer->format(),
                                        buffer->format_modifier());
     if (!framebuffer)
       return;

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

-// Copyright 2015 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/gbm_device.h"
-
-#include <utility>
-
-namespace ui {
-
-GbmDevice::GbmDevice(const base::FilePath& device_path,
-                     base::File file,
-                     bool is_primary_device)
-    : DrmDevice(device_path, std::move(file), is_primary_device) {}
-
-GbmDevice::~GbmDevice() = default;
-
-bool GbmDevice::Initialize() {
-  if (!DrmDevice::Initialize())
-    return false;
-
-  InitializeGbmDevice(get_fd());
-  if (!device()) {
-    PLOG(ERROR) << "Unable to initialize GBM for " << device_path().value();
-    return false;
-  }
-
-  return true;
-}
-
-}  // namespace ui

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

-// Copyright 2015 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_OZONE_PLATFORM_DRM_GPU_GBM_DEVICE_H_
-#define UI_OZONE_PLATFORM_DRM_GPU_GBM_DEVICE_H_
-
-#include "base/macros.h"
-#include "ui/ozone/platform/drm/gpu/drm_device.h"
-
-namespace ui {
-
-class GbmDevice : public DrmDevice {
- public:
-  GbmDevice(const base::FilePath& device_path,
-            base::File file,
-            bool is_primary_device);
-
-  // DrmDevice implementation:
-  bool Initialize() override;
-
- private:
-  ~GbmDevice() override;
-
-  DISALLOW_COPY_AND_ASSIGN(GbmDevice);
-};
-
-}  // namespace ui
-
-#endif  // UI_OZONE_PLATFORM_DRM_GPU_GBM_DEVICE_H_

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

@@ -11,11 +11,8 @@
 #include "ui/ozone/common/linux/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
 
-struct gbm_bo;
-
 namespace ui {
 
-class GbmDevice;
 class GbmSurfaceFactory;
 
 class GbmPixmap : public gfx::NativePixmap {