Revert "ozone: drm: Replace DrmFramebufferGenerator with fake GbmDevice"

Creation of modeset buffer for UDL devices is broken as if this change.

This reverts commit df7cd324.

Bug: 874755
Test: Connect UDL display.
TBR: dnicoara@chromium.org

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

ui/ozone/platform/drm/BUILD.gn

@@ -60,10 +60,10 @@ source_set("gbm") {
     "gpu/drm_window.h",
     "gpu/drm_window_proxy.cc",
     "gpu/drm_window_proxy.h",
-    "gpu/gbm_overlay_surface.cc",
-    "gpu/gbm_overlay_surface.h",
     "gpu/gbm_pixmap.cc",
     "gpu/gbm_pixmap.h",
+    "gpu/gbm_overlay_surface.cc",
+    "gpu/gbm_overlay_surface.h",
     "gpu/gbm_surface.cc",
     "gpu/gbm_surface.h",
     "gpu/gbm_surface_factory.cc",
@@ -90,6 +90,8 @@ source_set("gbm") {
     "gpu/page_flip_request.h",
     "gpu/proxy_helpers.cc",
     "gpu/proxy_helpers.h",
+    "gpu/drm_framebuffer.h",
+    "gpu/drm_framebuffer_generator.h",
     "gpu/screen_manager.cc",
     "gpu/screen_manager.h",
     "host/drm_cursor.cc",
@@ -182,8 +184,10 @@ source_set("gbm_unittests") {
     "gpu/hardware_display_plane_manager_unittest.cc",
     "gpu/mock_drm_device.cc",
     "gpu/mock_drm_device.h",
-    "gpu/mock_gbm_device.cc",
-    "gpu/mock_gbm_device.h",
+    "gpu/mock_dumb_buffer_generator.cc",
+    "gpu/mock_dumb_buffer_generator.h",
+    "gpu/mock_drm_framebuffer_generator.cc",
+    "gpu/mock_drm_framebuffer_generator.h",
     "gpu/proxy_helpers_unittest.cc",
     "gpu/screen_manager_unittest.cc",
   ]

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

@@ -5,7 +5,6 @@
 #include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
 
 #include "ui/ozone/common/linux/drm_util_linux.h"
-#include "ui/ozone/common/linux/gbm_buffer.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 
@@ -49,35 +48,6 @@ scoped_refptr<DrmFramebuffer> DrmFramebuffer::AddFramebuffer(
       gfx::Size(params.width, params.height));
 }
 
-// static
-scoped_refptr<DrmFramebuffer> DrmFramebuffer::AddFramebuffer(
-    scoped_refptr<DrmDevice> drm,
-    const GbmBuffer* buffer) {
-  gfx::Size size = buffer->GetSize();
-  AddFramebufferParams params;
-  params.format = buffer->GetFormat();
-  params.modifier = buffer->GetFormatModifier();
-  params.width = size.width();
-  params.height = size.height();
-  params.num_planes = buffer->GetNumPlanes();
-  for (size_t i = 0; i < params.num_planes; ++i) {
-    params.handles[i] = buffer->GetPlaneHandle(i);
-    params.strides[i] = buffer->GetPlaneStride(i);
-    params.offsets[i] = buffer->GetPlaneOffset(i);
-  }
-
-  // AddFramebuffer2 only considers the modifiers if addfb_flags has
-  // DRM_MODE_FB_MODIFIERS set. We only set that when we've created
-  // a bo with modifiers, otherwise, we rely on the "no modifiers"
-  // behavior doing the right thing.
-  params.flags = 0;
-  if (drm->allow_addfb2_modifiers() &&
-      params.modifier != DRM_FORMAT_MOD_INVALID)
-    params.flags |= DRM_MODE_FB_MODIFIERS;
-
-  return AddFramebuffer(std::move(drm), params);
-}
-
 DrmFramebuffer::DrmFramebuffer(scoped_refptr<DrmDevice> drm_device,
                                uint32_t framebuffer_id,
                                uint32_t framebuffer_pixel_format,

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

@@ -15,7 +15,6 @@
 namespace ui {
 
 class DrmDevice;
-class GbmBuffer;
 
 // Abstraction for a DRM buffer that can be scanned-out of.
 class DrmFramebuffer : public base::RefCountedThreadSafe<DrmFramebuffer> {
@@ -36,10 +35,6 @@ class DrmFramebuffer : public base::RefCountedThreadSafe<DrmFramebuffer> {
       scoped_refptr<DrmDevice> drm_device,
       AddFramebufferParams params);
 
-  static scoped_refptr<DrmFramebuffer> AddFramebuffer(
-      scoped_refptr<DrmDevice> drm_device,
-      const GbmBuffer* buffer);
-
   DrmFramebuffer(scoped_refptr<DrmDevice> drm_device,
                  uint32_t framebuffer_id,
                  uint32_t framebuffer_pixel_format,

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

+// Copyright 2018 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_SCANOUT_BUFFER_GENERATOR_H_
+#define UI_OZONE_PLATFORM_DRM_GPU_SCANOUT_BUFFER_GENERATOR_H_
+
+#include <vector>
+
+#include "base/memory/scoped_refptr.h"
+#include "ui/gfx/geometry/size.h"
+
+namespace ui {
+
+class DrmDevice;
+class DrmFramebuffer;
+
+class DrmFramebufferGenerator {
+ public:
+  virtual ~DrmFramebufferGenerator() {}
+
+  virtual scoped_refptr<DrmFramebuffer> Create(
+      const scoped_refptr<DrmDevice>& drm,
+      uint32_t format,
+      const std::vector<uint64_t>& modifiers,
+      const gfx::Size& size) = 0;
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_DRM_GPU_SCANOUT_BUFFER_GENERATOR_H_

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

@@ -10,10 +10,10 @@
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/ozone/common/linux/drm_util_linux.h"
-#include "ui/ozone/common/linux/gbm_buffer.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/drm_framebuffer.h"
+#include "ui/ozone/platform/drm/gpu/drm_framebuffer_generator.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 
@@ -25,6 +25,7 @@ scoped_refptr<DrmFramebuffer> GetBufferForPageFlipTest(
     const scoped_refptr<DrmDevice>& drm_device,
     const gfx::Size& size,
     uint32_t format,
+    DrmFramebufferGenerator* buffer_generator,
     std::vector<scoped_refptr<DrmFramebuffer>>* reusable_buffers) {
   // Check if we can re-use existing buffers.
   for (const auto& buffer : *reusable_buffers) {
@@ -34,24 +35,22 @@ scoped_refptr<DrmFramebuffer> GetBufferForPageFlipTest(
     }
   }
 
-  // TODO(dcastagna): use the right modifiers.
-  std::unique_ptr<GbmBuffer> buffer =
-      drm_device->gbm_device()->CreateBuffer(format, size, GBM_BO_USE_SCANOUT);
-  if (!buffer)
-    return nullptr;
-
+  const std::vector<uint64_t>
+      modifiers;  // TODO(dcastagna): use the right modifiers.
   scoped_refptr<DrmFramebuffer> drm_framebuffer =
-      DrmFramebuffer::AddFramebuffer(drm_device, buffer.get());
-  if (!drm_framebuffer)
-    return nullptr;
+      buffer_generator->Create(drm_device, format, modifiers, size);
+  if (drm_framebuffer)
+    reusable_buffers->push_back(drm_framebuffer);
 
-  reusable_buffers->push_back(drm_framebuffer);
   return drm_framebuffer;
 }
 
 }  // namespace
 
-DrmOverlayValidator::DrmOverlayValidator(DrmWindow* window) : window_(window) {}
+DrmOverlayValidator::DrmOverlayValidator(
+    DrmWindow* window,
+    DrmFramebufferGenerator* buffer_generator)
+    : window_(window), buffer_generator_(buffer_generator) {}
 
 DrmOverlayValidator::~DrmOverlayValidator() {}
 
@@ -83,7 +82,8 @@ std::vector<OverlayCheckReturn_Params> DrmOverlayValidator::TestPageFlip(
 
     scoped_refptr<DrmFramebuffer> buffer = GetBufferForPageFlipTest(
         drm, params[i].buffer_size,
-        GetFourCCFormatFromBufferFormat(params[i].format), &reusable_buffers);
+        GetFourCCFormatFromBufferFormat(params[i].format), buffer_generator_,
+        &reusable_buffers);
 
     DrmOverlayPlane plane(buffer, params[i].plane_z_order, params[i].transform,
                           params[i].display_rect, params[i].crop_rect,

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

@@ -11,12 +11,14 @@
 namespace ui {
 
 class DrmWindow;
+class DrmFramebufferGenerator;
 struct OverlayCheck_Params;
 struct OverlayCheckReturn_Params;
 
 class DrmOverlayValidator {
  public:
-  DrmOverlayValidator(DrmWindow* window);
+  DrmOverlayValidator(DrmWindow* window,
+                      DrmFramebufferGenerator* buffer_generator);
   ~DrmOverlayValidator();
 
   // Tests if configurations |params| are compatible with |window_| and finds
@@ -28,6 +30,7 @@ class DrmOverlayValidator {
 
  private:
   DrmWindow* window_;  // Not owned.
+  DrmFramebufferGenerator* buffer_generator_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(DrmOverlayValidator);
 };

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

@@ -15,16 +15,14 @@
 #include "ui/gfx/gpu_fence.h"
 #include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
 #include "ui/ozone/common/linux/drm_util_linux.h"
-#include "ui/ozone/common/linux/gbm_buffer.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_framebuffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 #include "ui/ozone/platform/drm/gpu/mock_drm_device.h"
-#include "ui/ozone/platform/drm/gpu/mock_gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/mock_drm_framebuffer_generator.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 
 namespace {
@@ -64,16 +62,8 @@ class DrmOverlayValidatorTest : public testing::Test {
   void AddPlane(const ui::OverlayCheck_Params& params);
 
   scoped_refptr<ui::DrmFramebuffer> CreateBuffer() {
-    auto gbm_buffer = drm_->gbm_device()->CreateBuffer(
-        DRM_FORMAT_XRGB8888, primary_rect_.size(), GBM_BO_USE_SCANOUT);
-    return ui::DrmFramebuffer::AddFramebuffer(drm_, gbm_buffer.get());
-  }
-
-  scoped_refptr<ui::DrmFramebuffer> CreateOverlayBuffer(uint32_t format,
-                                                        const gfx::Size& size) {
-    auto gbm_buffer =
-        drm_->gbm_device()->CreateBuffer(format, size, GBM_BO_USE_SCANOUT);
-    return ui::DrmFramebuffer::AddFramebuffer(drm_, gbm_buffer.get());
+    return buffer_generator_->CreateWithModifier(
+        drm_, DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE, primary_rect_.size());
   }
 
  protected:
@@ -89,7 +79,7 @@ class DrmOverlayValidatorTest : public testing::Test {
 
   std::unique_ptr<base::MessageLoop> message_loop_;
   scoped_refptr<ui::MockDrmDevice> drm_;
-  ui::MockGbmDevice* gbm_ = nullptr;
+  std::unique_ptr<ui::MockDrmFramebufferGenerator> buffer_generator_;
   std::unique_ptr<ui::ScreenManager> screen_manager_;
   std::unique_ptr<ui::DrmDeviceManager> drm_device_manager_;
   ui::DrmWindow* window_;
@@ -111,16 +101,15 @@ void DrmOverlayValidatorTest::SetUp() {
   last_swap_buffers_result_ = gfx::SwapResult::SWAP_FAILED;
 
   message_loop_.reset(new base::MessageLoopForUI);
-  auto gbm = std::make_unique<ui::MockGbmDevice>();
-  gbm_ = gbm.get();
-  drm_ = new ui::MockDrmDevice(std::move(gbm));
+  drm_ = new ui::MockDrmDevice;
 
   CrtcState crtc_state = {.planes = {
                               {.formats = {DRM_FORMAT_XRGB8888}},
                           }};
   InitializeDrmState({crtc_state});
 
-  screen_manager_.reset(new ui::ScreenManager());
+  buffer_generator_.reset(new ui::MockDrmFramebufferGenerator());
+  screen_manager_.reset(new ui::ScreenManager(buffer_generator_.get()));
   screen_manager_->AddDisplayController(drm_, kCrtcIdBase, kConnectorIdBase);
   screen_manager_->ConfigureDisplayController(
       drm_, kCrtcIdBase, kConnectorIdBase, gfx::Point(), kDefaultMode);
@@ -129,12 +118,13 @@ void DrmOverlayValidatorTest::SetUp() {
 
   std::unique_ptr<ui::DrmWindow> window(new ui::DrmWindow(
       kDefaultWidgetHandle, drm_device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(
       gfx::Rect(gfx::Size(kDefaultMode.hdisplay, kDefaultMode.vdisplay)));
   screen_manager_->AddWindow(kDefaultWidgetHandle, std::move(window));
   window_ = screen_manager_->GetWindow(kDefaultWidgetHandle);
-  overlay_validator_.reset(new ui::DrmOverlayValidator(window_));
+  overlay_validator_.reset(
+      new ui::DrmOverlayValidator(window_, buffer_generator_.get()));
 
   overlay_rect_ =
       gfx::Rect(0, 0, kDefaultMode.hdisplay / 2, kDefaultMode.vdisplay / 2);
@@ -220,9 +210,9 @@ void DrmOverlayValidatorTest::InitializeDrmState(
 
 void DrmOverlayValidatorTest::AddPlane(const ui::OverlayCheck_Params& params) {
   scoped_refptr<ui::DrmDevice> drm = window_->GetController()->GetDrmDevice();
-
-  scoped_refptr<ui::DrmFramebuffer> drm_framebuffer = CreateOverlayBuffer(
-      ui::GetFourCCFormatFromBufferFormat(params.format), params.buffer_size);
+  scoped_refptr<ui::DrmFramebuffer> drm_framebuffer = buffer_generator_->Create(
+      drm, ui::GetFourCCFormatFromBufferFormat(params.format), {},
+      params.buffer_size);
   plane_list_.push_back(ui::DrmOverlayPlane(
       std::move(drm_framebuffer), params.plane_z_order, params.transform,
       params.display_rect, params.crop_rect, true, nullptr));
@@ -479,7 +469,7 @@ TEST_F(DrmOverlayValidatorTest, OptimalFormatXRGB_MirroredControllers) {
 TEST_F(DrmOverlayValidatorTest, RejectBufferAllocationFail) {
   // Buffer allocation for scanout might fail.
   // In that case we should reject the overlay candidate.
-  gbm_->set_allocation_failure(true);
+  buffer_generator_->set_allocation_failure(true);
 
   std::vector<ui::OverlayCheckReturn_Params> returns =
       overlay_validator_->TestPageFlip(overlay_params_,

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

@@ -22,6 +22,7 @@
 #include "ui/ozone/platform/drm/gpu/drm_buffer.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_framebuffer_generator.h"
 #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"
@@ -35,6 +36,34 @@ namespace ui {
 
 namespace {
 
+scoped_refptr<DrmFramebuffer> AddFramebuffersForBuffer(
+    const scoped_refptr<DrmDevice>& drm,
+    GbmBuffer* buffer) {
+  gfx::Size size = buffer->GetSize();
+  DrmFramebuffer::AddFramebufferParams params;
+  params.format = buffer->GetFormat();
+  params.modifier = buffer->GetFormatModifier();
+  params.width = size.width();
+  params.height = size.height();
+  params.num_planes = buffer->GetNumPlanes();
+  for (size_t i = 0; i < params.num_planes; ++i) {
+    params.handles[i] = buffer->GetPlaneHandle(i);
+    params.strides[i] = buffer->GetPlaneStride(i);
+    params.offsets[i] = buffer->GetPlaneOffset(i);
+  }
+
+  // AddFramebuffer2 only considers the modifiers if addfb_flags has
+  // DRM_MODE_FB_MODIFIERS set. We only set that when we've created
+  // a bo with modifiers, otherwise, we rely on the "no modifiers"
+  // behavior doing the right thing.
+  params.flags = 0;
+  if (drm->allow_addfb2_modifiers() &&
+      params.modifier != DRM_FORMAT_MOD_INVALID)
+    params.flags |= DRM_MODE_FB_MODIFIERS;
+
+  return DrmFramebuffer::AddFramebuffer(drm, params);
+}
+
 uint32_t BufferUsageToGbmFlags(gfx::BufferUsage usage) {
   switch (usage) {
     case gfx::BufferUsage::GPU_READ:
@@ -77,7 +106,7 @@ void CreateBufferWithGbmFlags(const scoped_refptr<DrmDevice>& drm,
 
   scoped_refptr<DrmFramebuffer> framebuffer;
   if (flags & GBM_BO_USE_SCANOUT) {
-    framebuffer = DrmFramebuffer::AddFramebuffer(drm, buffer.get());
+    framebuffer = AddFramebuffersForBuffer(drm, buffer.get());
     if (!framebuffer)
       return;
   }
@@ -86,6 +115,36 @@ void CreateBufferWithGbmFlags(const scoped_refptr<DrmDevice>& drm,
   *out_framebuffer = std::move(framebuffer);
 }
 
+class GbmBufferGenerator : public DrmFramebufferGenerator {
+ public:
+  GbmBufferGenerator() {}
+  ~GbmBufferGenerator() override {}
+
+  // DrmFramebufferGenerator:
+  scoped_refptr<DrmFramebuffer> Create(const scoped_refptr<DrmDevice>& drm,
+                                       uint32_t format,
+                                       const std::vector<uint64_t>& modifiers,
+                                       const gfx::Size& size) override {
+    std::unique_ptr<GbmBuffer> buffer;
+
+    if (modifiers.size() > 0) {
+      buffer = drm->gbm_device()->CreateBufferWithModifiers(
+          format, size, GBM_BO_USE_SCANOUT, modifiers);
+    } else {
+      buffer =
+          drm->gbm_device()->CreateBuffer(format, size, GBM_BO_USE_SCANOUT);
+    }
+
+    if (!buffer)
+      return nullptr;
+
+    return AddFramebuffersForBuffer(drm, buffer.get());
+  }
+
+ protected:
+  DISALLOW_COPY_AND_ASSIGN(GbmBufferGenerator);
+};
+
 class GbmDeviceGenerator : public DrmDeviceGenerator {
  public:
   GbmDeviceGenerator() {}
@@ -134,7 +193,8 @@ void DrmThread::Start(base::OnceClosure binding_completer) {
 void DrmThread::Init() {
   device_manager_.reset(
       new DrmDeviceManager(std::make_unique<GbmDeviceGenerator>()));
-  screen_manager_.reset(new ScreenManager());
+  buffer_generator_.reset(new GbmBufferGenerator());
+  screen_manager_.reset(new ScreenManager(buffer_generator_.get()));
 
   display_manager_.reset(
       new DrmGpuDisplayManager(screen_manager_.get(), device_manager_.get()));
@@ -204,7 +264,7 @@ void DrmThread::CreateBufferFromFds(
   if (buffer->GetFlags() & GBM_BO_USE_SCANOUT) {
     // NB: This is not required to succeed; framebuffers are added for
     // imported buffers on a best effort basis.
-    framebuffer = DrmFramebuffer::AddFramebuffer(drm, buffer.get());
+    framebuffer = AddFramebuffersForBuffer(drm, buffer.get());
   }
 
   *out_buffer = std::move(buffer);
@@ -268,7 +328,7 @@ void DrmThread::IsDeviceAtomic(gfx::AcceleratedWidget widget, bool* is_atomic) {
 void DrmThread::CreateWindow(gfx::AcceleratedWidget widget) {
   std::unique_ptr<DrmWindow> window(
       new DrmWindow(widget, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   screen_manager_->AddWindow(widget, std::move(window));
 }
 

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

@@ -44,6 +44,7 @@ class DrmDeviceManager;
 class DrmFramebuffer;
 class DrmGpuDisplayManager;
 class GbmBuffer;
+class DrmFramebufferGenerator;
 class ScreenManager;
 
 struct DrmOverlayPlane;
@@ -154,6 +155,7 @@ class DrmThread : public base::Thread,
                                 std::vector<DrmOverlayPlane> planes);
 
   std::unique_ptr<DrmDeviceManager> device_manager_;
+  std::unique_ptr<DrmFramebufferGenerator> buffer_generator_;
   std::unique_ptr<ScreenManager> screen_manager_;
   std::unique_ptr<DrmGpuDisplayManager> display_manager_;
 

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

@@ -37,11 +37,12 @@ DrmWindow::DrmWindow(gfx::AcceleratedWidget widget,
 DrmWindow::~DrmWindow() {
 }
 
-void DrmWindow::Initialize() {
+void DrmWindow::Initialize(DrmFramebufferGenerator* buffer_generator) {
   TRACE_EVENT1("drm", "DrmWindow::Initialize", "widget", widget_);
 
   device_manager_->UpdateDrmDevice(widget_, nullptr);
-  overlay_validator_ = std::make_unique<DrmOverlayValidator>(this);
+  overlay_validator_ =
+      std::make_unique<DrmOverlayValidator>(this, buffer_generator);
 }
 
 void DrmWindow::Shutdown() {

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

@@ -33,6 +33,7 @@ class DrmOverlayValidator;
 class HardwareDisplayController;
 struct OverlayCheck_Params;
 struct OverlayCheckReturn_Params;
+class DrmFramebufferGenerator;
 class ScreenManager;
 
 // The GPU object representing a window.
@@ -54,7 +55,7 @@ class DrmWindow {
 
   gfx::Rect bounds() const { return bounds_; }
 
-  void Initialize();
+  void Initialize(DrmFramebufferGenerator* buffer_generator);
 
   void Shutdown();
 

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

@@ -21,13 +21,12 @@
 #include "third_party/skia/include/core/SkSurface.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/presentation_feedback.h"
-#include "ui/ozone/common/linux/gbm_buffer.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_framebuffer.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 #include "ui/ozone/platform/drm/gpu/mock_drm_device.h"
-#include "ui/ozone/platform/drm/gpu/mock_gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/mock_dumb_buffer_generator.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
 
@@ -86,6 +85,7 @@ class DrmWindowTest : public testing::Test {
  protected:
   std::unique_ptr<base::MessageLoop> message_loop_;
   scoped_refptr<ui::MockDrmDevice> drm_;
+  std::unique_ptr<ui::MockDumbBufferGenerator> buffer_generator_;
   std::unique_ptr<ui::ScreenManager> screen_manager_;
   std::unique_ptr<ui::DrmDeviceManager> drm_device_manager_;
 
@@ -102,9 +102,9 @@ void DrmWindowTest::SetUp() {
   last_swap_buffers_result_ = gfx::SwapResult::SWAP_FAILED;
 
   message_loop_.reset(new base::MessageLoopForUI);
-  auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-  drm_ = new ui::MockDrmDevice(std::move(gbm_device));
-  screen_manager_.reset(new ui::ScreenManager());
+  drm_ = new ui::MockDrmDevice;
+  buffer_generator_.reset(new ui::MockDumbBufferGenerator());
+  screen_manager_.reset(new ui::ScreenManager(buffer_generator_.get()));
   screen_manager_->AddDisplayController(drm_, kDefaultCrtc, kDefaultConnector);
   screen_manager_->ConfigureDisplayController(
       drm_, kDefaultCrtc, kDefaultConnector, gfx::Point(), kDefaultMode);
@@ -113,7 +113,7 @@ void DrmWindowTest::SetUp() {
 
   std::unique_ptr<ui::DrmWindow> window(new ui::DrmWindow(
       kDefaultWidgetHandle, drm_device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(
       gfx::Rect(gfx::Size(kDefaultMode.hdisplay, kDefaultMode.vdisplay)));
   screen_manager_->AddWindow(kDefaultWidgetHandle, std::move(window));
@@ -159,9 +159,7 @@ TEST_F(DrmWindowTest, CheckCursorSurfaceAfterChangingDevice) {
                   gfx::Point(4, 2), 0);
 
   // Add another device.
-  auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-  scoped_refptr<ui::MockDrmDevice> drm =
-      new ui::MockDrmDevice(std::move(gbm_device));
+  scoped_refptr<ui::MockDrmDevice> drm = new ui::MockDrmDevice;
   screen_manager_->AddDisplayController(drm, kDefaultCrtc, kDefaultConnector);
   screen_manager_->ConfigureDisplayController(
       drm, kDefaultCrtc, kDefaultConnector,
@@ -179,13 +177,11 @@ TEST_F(DrmWindowTest, CheckCursorSurfaceAfterChangingDevice) {
 
 TEST_F(DrmWindowTest, CheckDeathOnFailedSwap) {
   const gfx::Size window_size(6, 4);
+  ui::MockDumbBufferGenerator buffer_generator;
   ui::DrmWindow* window = screen_manager_->GetWindow(kDefaultWidgetHandle);
-
-  std::unique_ptr<ui::GbmBuffer> buffer = drm_->gbm_device()->CreateBuffer(
-      DRM_FORMAT_XRGB8888, window_size, GBM_BO_USE_SCANOUT);
-  scoped_refptr<ui::DrmFramebuffer> framebuffer =
-      ui::DrmFramebuffer::AddFramebuffer(drm_, buffer.get());
-  ui::DrmOverlayPlane plane(framebuffer, nullptr);
+  ui::DrmOverlayPlane plane(
+      buffer_generator.Create(drm_, DRM_FORMAT_XRGB8888, {}, window_size),
+      nullptr);
 
   drm_->set_page_flip_expectation(false);
 

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

@@ -13,14 +13,12 @@
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/native_pixmap.h"
 #include "ui/gfx/presentation_feedback.h"
-#include "ui/ozone/common/linux/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
-#include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_util.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane.h"
 #include "ui/ozone/platform/drm/gpu/mock_drm_device.h"
-#include "ui/ozone/platform/drm/gpu/mock_gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/mock_drm_framebuffer_generator.h"
 
 namespace {
 
@@ -59,18 +57,17 @@ class HardwareDisplayControllerTest : public testing::Test {
                                  const std::string& property_name);
 
   scoped_refptr<ui::DrmFramebuffer> CreateBuffer() {
-    std::unique_ptr<ui::GbmBuffer> buffer = drm_->gbm_device()->CreateBuffer(
-        DRM_FORMAT_XRGB8888, kDefaultModeSize, GBM_BO_USE_SCANOUT);
-    return ui::DrmFramebuffer::AddFramebuffer(drm_, buffer.get());
+    return buffer_generator_->CreateWithModifier(
+        drm_, DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE, kDefaultModeSize);
   }
 
   scoped_refptr<ui::DrmFramebuffer> CreateOverlayBuffer() {
-    std::unique_ptr<ui::GbmBuffer> buffer = drm_->gbm_device()->CreateBuffer(
-        DRM_FORMAT_XRGB8888, kOverlaySize, GBM_BO_USE_SCANOUT);
-    return ui::DrmFramebuffer::AddFramebuffer(drm_, buffer.get());
+    return buffer_generator_->CreateWithModifier(
+        drm_, DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE, kOverlaySize);
   }
 
  protected:
+  std::unique_ptr<ui::MockDrmFramebufferGenerator> buffer_generator_;
   std::unique_ptr<ui::HardwareDisplayController> controller_;
   scoped_refptr<ui::MockDrmDevice> drm_;
 
@@ -86,10 +83,10 @@ void HardwareDisplayControllerTest::SetUp() {
   page_flips_ = 0;
   last_swap_result_ = gfx::SwapResult::SWAP_FAILED;
 
-  auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-  drm_ = new ui::MockDrmDevice(std::move(gbm_device));
+  drm_ = new ui::MockDrmDevice;
   InitializeDrmDevice(/* use_atomic= */ true);
 
+  buffer_generator_.reset(new ui::MockDrmFramebufferGenerator());
   controller_.reset(new ui::HardwareDisplayController(
       std::unique_ptr<ui::CrtcController>(
           new ui::CrtcController(drm_.get(), kPrimaryCrtc, kPrimaryConnector)),

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

@@ -17,15 +17,13 @@
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/gpu_fence_handle.h"
-#include "ui/ozone/common/linux/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
-#include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_util.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.h"
 #include "ui/ozone/platform/drm/gpu/mock_drm_device.h"
-#include "ui/ozone/platform/drm/gpu/mock_gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/mock_drm_framebuffer_generator.h"
 
 namespace {
 
@@ -64,20 +62,21 @@ class HardwareDisplayPlaneManagerTest
   void SetUp() override;
 
   scoped_refptr<ui::DrmFramebuffer> CreateBuffer(const gfx::Size& size) {
-    return CreateBufferWithFormat(size, DRM_FORMAT_XRGB8888);
+    return buffer_generator_->CreateWithModifier(fake_drm_, DRM_FORMAT_XRGB8888,
+                                                 DRM_FORMAT_MOD_NONE, size);
   }
 
   scoped_refptr<ui::DrmFramebuffer> CreateBufferWithFormat(
       const gfx::Size& size,
       uint32_t format) {
-    std::unique_ptr<ui::GbmBuffer> buffer =
-        fake_drm_->gbm_device()->CreateBuffer(format, size, GBM_BO_USE_SCANOUT);
-    return ui::DrmFramebuffer::AddFramebuffer(fake_drm_, buffer.get());
+    return buffer_generator_->CreateWithModifier(fake_drm_, format,
+                                                 DRM_FORMAT_MOD_NONE, size);
   }
 
  protected:
   ui::HardwareDisplayPlaneList state_;
   scoped_refptr<ui::DrmFramebuffer> fake_buffer_;
+  std::unique_ptr<ui::MockDrmFramebufferGenerator> buffer_generator_;
   scoped_refptr<ui::MockDrmDevice> fake_drm_;
 
   std::vector<ui::MockDrmDevice::CrtcProperties> crtc_properties_;
@@ -92,9 +91,9 @@ class HardwareDisplayPlaneManagerTest
 
 void HardwareDisplayPlaneManagerTest::SetUp() {
   use_atomic_ = GetParam();
+  buffer_generator_.reset(new ui::MockDrmFramebufferGenerator());
 
-  auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-  fake_drm_ = new ui::MockDrmDevice(std::move(gbm_device));
+  fake_drm_ = new ui::MockDrmDevice;
   fake_drm_->SetPropertyBlob(ui::MockDrmDevice::AllocateInFormatsBlob(
       kInFormatsBlobPropId, {DRM_FORMAT_XRGB8888}, {}));
 
@@ -299,7 +298,7 @@ TEST_P(HardwareDisplayPlaneManagerLegacyTest, MultiplePlanesAndCrtcs) {
 TEST_P(HardwareDisplayPlaneManagerLegacyTest, CheckFramebufferFormatMatch) {
   ui::DrmOverlayPlaneList assigns;
   scoped_refptr<ui::DrmFramebuffer> buffer =
-      CreateBufferWithFormat(kDefaultBufferSize, DRM_FORMAT_UYVY);
+      CreateBufferWithFormat(kDefaultBufferSize, DRM_FORMAT_NV12);
   assigns.push_back(ui::DrmOverlayPlane(buffer, nullptr));
 
   InitializeDrmState(/*crtc_count=*/2, /*planes_per_crtc=*/1);
@@ -783,8 +782,8 @@ class HardwareDisplayPlaneManagerPlanesReadyTest : public testing::Test {
   HardwareDisplayPlaneManagerPlanesReadyTest() {}
 
   void SetUp() override {
-    auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-    fake_drm_ = new ui::MockDrmDevice(std::move(gbm_device));
+    fake_drm_ = new ui::MockDrmDevice;
+    buffer_generator_.reset(new ui::MockDrmFramebufferGenerator());
     drm_framebuffer_ = CreateBuffer(kDefaultBufferSize);
     planes_without_fences_ = CreatePlanesWithoutFences();
     planes_with_fences_ = CreatePlanesWithFences();
@@ -795,10 +794,8 @@ class HardwareDisplayPlaneManagerPlanesReadyTest : public testing::Test {
   void RequestPlanesReady(ui::DrmOverlayPlaneList planes);
 
   scoped_refptr<ui::DrmFramebuffer> CreateBuffer(const gfx::Size& size) {
-    std::unique_ptr<ui::GbmBuffer> buffer =
-        fake_drm_->gbm_device()->CreateBuffer(DRM_FORMAT_XRGB8888, size,
-                                              GBM_BO_USE_SCANOUT);
-    return ui::DrmFramebuffer::AddFramebuffer(fake_drm_, buffer.get());
+    return buffer_generator_->CreateWithModifier(fake_drm_, DRM_FORMAT_XRGB8888,
+                                                 DRM_FORMAT_MOD_NONE, size);
   }
 
   ui::DrmOverlayPlaneList CreatePlanesWithoutFences() {
@@ -820,6 +817,7 @@ class HardwareDisplayPlaneManagerPlanesReadyTest : public testing::Test {
   }
 
   scoped_refptr<ui::MockDrmDevice> fake_drm_;
+  std::unique_ptr<ui::MockDrmFramebufferGenerator> buffer_generator_;
   std::unique_ptr<ui::HardwareDisplayPlaneManager> plane_manager_;
   bool callback_called = false;
   base::test::ScopedTaskEnvironment task_env_{
@@ -928,26 +926,24 @@ class HardwareDisplayPlaneAtomicMock : public ui::HardwareDisplayPlaneAtomic {
 TEST(HardwareDisplayPlaneManagerAtomic, EnableBlend) {
   auto plane_manager =
       std::make_unique<ui::HardwareDisplayPlaneManagerAtomic>();
-  auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-  auto drm_device =
-      base::MakeRefCounted<ui::MockDrmDevice>(std::move(gbm_device));
+  auto drm_device = base::MakeRefCounted<ui::MockDrmDevice>();
+  auto buffer_generator = std::make_unique<ui::MockDrmFramebufferGenerator>();
   ui::HardwareDisplayPlaneList plane_list;
   HardwareDisplayPlaneAtomicMock hw_plane;
-  std::unique_ptr<ui::GbmBuffer> buffer =
-      drm_device->gbm_device()->CreateBuffer(
-          DRM_FORMAT_XRGB8888, kDefaultBufferSize, GBM_BO_USE_SCANOUT);
-  scoped_refptr<ui::DrmFramebuffer> framebuffer =
-      ui::DrmFramebuffer::AddFramebuffer(drm_device, buffer.get());
-  ui::DrmOverlayPlane overlay(framebuffer, nullptr);
+  scoped_refptr<ui::DrmFramebuffer> buffer =
+      buffer_generator->CreateWithModifier(
+          drm_device.get(), DRM_FORMAT_XRGB8888, DRM_FORMAT_MOD_NONE,
+          kDefaultBufferSize);
+  ui::DrmOverlayPlane overlay(buffer, nullptr);
   overlay.enable_blend = true;
   plane_manager->SetPlaneData(&plane_list, &hw_plane, overlay, 1, gfx::Rect(),
                               nullptr);
-  EXPECT_EQ(hw_plane.framebuffer(), framebuffer->framebuffer_id());
+  EXPECT_EQ(hw_plane.framebuffer(), buffer->framebuffer_id());
 
   overlay.enable_blend = false;
   plane_manager->SetPlaneData(&plane_list, &hw_plane, overlay, 1, gfx::Rect(),
                               nullptr);
-  EXPECT_EQ(hw_plane.framebuffer(), framebuffer->opaque_framebuffer_id());
+  EXPECT_EQ(hw_plane.framebuffer(), buffer->opaque_framebuffer_id());
 }
 
 }  // namespace

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

@@ -73,11 +73,11 @@ MockDrmDevice::PlaneProperties::PlaneProperties(const PlaneProperties&) =
     default;
 MockDrmDevice::PlaneProperties::~PlaneProperties() = default;
 
-MockDrmDevice::MockDrmDevice(std::unique_ptr<GbmDevice> gbm_device)
+MockDrmDevice::MockDrmDevice()
     : DrmDevice(base::FilePath(),
                 base::File(),
                 true /* is_primary_device */,
-                std::move(gbm_device)),
+                nullptr),
       get_crtc_call_count_(0),
       set_crtc_call_count_(0),
       restore_crtc_call_count_(0),

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

@@ -44,7 +44,7 @@ class MockDrmDevice : public DrmDevice {
     std::vector<DrmDevice::Property> properties;
   };
 
-  MockDrmDevice(std::unique_ptr<GbmDevice> gbm_device);
+  MockDrmDevice();
 
   static ScopedDrmPropertyBlobPtr AllocateInFormatsBlob(
       uint32_t id,

ui/ozone/platform/drm/gpu/mock_drm_framebuffer_generator.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/mock_drm_framebuffer_generator.h"
+
+#include <drm_fourcc.h>
+
+#include "ui/ozone/platform/drm/common/drm_util.h"
+#include "ui/ozone/platform/drm/gpu/drm_device.h"
+
+namespace ui {
+
+namespace {
+
+uint32_t g_current_mock_buffer_handle = 0x1111;
+
+}  // namespace
+
+MockDrmFramebufferGenerator::MockDrmFramebufferGenerator() {}
+
+MockDrmFramebufferGenerator::~MockDrmFramebufferGenerator() {}
+
+scoped_refptr<DrmFramebuffer> MockDrmFramebufferGenerator::Create(
+    const scoped_refptr<DrmDevice>& drm,
+    uint32_t format,
+    const std::vector<uint64_t>& modifiers,
+    const gfx::Size& size) {
+  return CreateWithModifier(
+      drm, format, modifiers.empty() ? DRM_FORMAT_MOD_NONE : modifiers.front(),
+      size);
+}
+
+scoped_refptr<DrmFramebuffer> MockDrmFramebufferGenerator::CreateWithModifier(
+    const scoped_refptr<DrmDevice>& drm,
+    uint32_t format,
+    uint64_t modifier,
+    const gfx::Size& size) {
+  if (allocation_failure_)
+    return nullptr;
+
+  DrmFramebuffer::AddFramebufferParams params;
+  params.format = format;
+  params.modifier = modifier;
+  params.width = size.width();
+  params.height = size.height();
+  params.num_planes = 1;
+  params.handles[0] = g_current_mock_buffer_handle++;
+
+  return DrmFramebuffer::AddFramebuffer(drm, params);
+}
+
+}  // namespace ui

ui/ozone/platform/drm/gpu/mock_drm_framebuffer_generator.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_MOCK_SCANOUT_BUFFER_GENERATOR_H_
+#define UI_OZONE_PLATFORM_DRM_GPU_MOCK_SCANOUT_BUFFER_GENERATOR_H_
+
+#include "base/macros.h"
+
+#include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
+#include "ui/ozone/platform/drm/gpu/drm_framebuffer_generator.h"
+
+namespace ui {
+
+class MockDrmFramebufferGenerator : public DrmFramebufferGenerator {
+ public:
+  MockDrmFramebufferGenerator();
+  ~MockDrmFramebufferGenerator() override;
+
+  // DrmFramebufferGenerator:
+  scoped_refptr<DrmFramebuffer> Create(const scoped_refptr<DrmDevice>& drm,
+                                       uint32_t format,
+                                       const std::vector<uint64_t>& modifiers,
+                                       const gfx::Size& size) override;
+
+  scoped_refptr<DrmFramebuffer> CreateWithModifier(
+      const scoped_refptr<DrmDevice>& drm,
+      uint32_t format,
+      uint64_t modifier,
+      const gfx::Size& size);
+
+  void set_allocation_failure(bool allocation_failure) {
+    allocation_failure_ = allocation_failure;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockDrmFramebufferGenerator);
+
+  bool allocation_failure_ = false;
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_DRM_GPU_MOCK_SCANOUT_BUFFER_GENERATOR_H_

ui/ozone/platform/drm/gpu/mock_dumb_buffer_generator.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/mock_dumb_buffer_generator.h"
+
+#include "third_party/skia/include/core/SkImageInfo.h"
+#include "ui/ozone/platform/drm/gpu/drm_buffer.h"
+#include "ui/ozone/platform/drm/gpu/drm_device.h"
+
+namespace ui {
+
+namespace {
+
+uint32_t GetFourCCCodeForSkColorType(SkColorType type) {
+  switch (type) {
+    case kUnknown_SkColorType:
+    case kAlpha_8_SkColorType:
+      return 0;
+    case kRGB_565_SkColorType:
+      return DRM_FORMAT_RGB565;
+    case kARGB_4444_SkColorType:
+      return DRM_FORMAT_ARGB4444;
+    case kN32_SkColorType:
+      return DRM_FORMAT_ARGB8888;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
+scoped_refptr<DrmFramebuffer> AddFramebufferForDumbBuffer(
+    const scoped_refptr<DrmDevice>& drm,
+    uint32_t handle,
+    uint32_t stride,
+    const SkImageInfo& info) {
+  DrmFramebuffer::AddFramebufferParams params;
+  params.flags = 0;
+  params.format = GetFourCCCodeForSkColorType(info.colorType());
+  params.modifier = DRM_FORMAT_MOD_INVALID;
+  params.width = info.width();
+  params.height = info.height();
+  params.num_planes = 1;
+  params.handles[0] = handle;
+  params.strides[0] = stride;
+  return DrmFramebuffer::AddFramebuffer(drm, params);
+}
+
+}  // namespace
+
+MockDumbBufferGenerator::MockDumbBufferGenerator() {}
+
+MockDumbBufferGenerator::~MockDumbBufferGenerator() {}
+
+scoped_refptr<DrmFramebuffer> MockDumbBufferGenerator::Create(
+    const scoped_refptr<DrmDevice>& drm,
+    uint32_t format,
+    const std::vector<uint64_t>& modifiers,
+    const gfx::Size& size) {
+  std::unique_ptr<DrmBuffer> buffer(new DrmBuffer(drm));
+  SkImageInfo info = SkImageInfo::MakeN32Premul(size.width(), size.height());
+  if (!buffer->Initialize(info))
+    return NULL;
+
+  return AddFramebufferForDumbBuffer(drm, buffer->GetHandle(), buffer->stride(),
+                                     info);
+}
+
+}  // namespace ui

ui/ozone/platform/drm/gpu/mock_dumb_buffer_generator.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_MOCK_DUMB_BUFFER_GENERATOR_H_
+#define UI_OZONE_PLATFORM_DRM_GPU_MOCK_DUMB_BUFFER_GENERATOR_H_
+
+#include "base/macros.h"
+
+#include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
+#include "ui/ozone/platform/drm/gpu/drm_framebuffer_generator.h"
+
+namespace ui {
+
+class DrmFramebuffer;
+
+class MockDumbBufferGenerator : public DrmFramebufferGenerator {
+ public:
+  MockDumbBufferGenerator();
+  ~MockDumbBufferGenerator() override;
+
+  // DrmFramebufferGenerator:
+  scoped_refptr<DrmFramebuffer> Create(const scoped_refptr<DrmDevice>& drm,
+                                       uint32_t format,
+                                       const std::vector<uint64_t>& modifiers,
+                                       const gfx::Size& size) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockDumbBufferGenerator);
+};
+
+}  // namespace ui
+
+#endif  // UI_OZONE_PLATFORM_DRM_GPU_MOCK_DUMB_BUFFER_GENERATOR_H_

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

-// Copyright 2018 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/mock_gbm_device.h"
-
-#include <drm_fourcc.h>
-#include <xf86drm.h>
-
-#include "base/logging.h"
-#include "base/numerics/safe_math.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "ui/ozone/common/linux/drm_util_linux.h"
-#include "ui/ozone/common/linux/gbm_buffer.h"
-
-namespace ui {
-namespace {
-
-class MockGbmBuffer final : public ui::GbmBuffer {
- public:
-  MockGbmBuffer(uint32_t format,
-                uint32_t flags,
-                uint64_t modifier,
-                const gfx::Size& size,
-                std::vector<gfx::NativePixmapPlane> planes,
-                std::vector<uint32_t> handles)
-      : format_(format),
-        format_modifier_(modifier),
-        flags_(flags),
-        size_(size),
-        planes_(std::move(planes)),
-        handles_(std::move(handles)) {}
-
-  ~MockGbmBuffer() override {}
-
-  uint32_t GetFormat() const override { return format_; }
-  uint64_t GetFormatModifier() const override { return format_modifier_; }
-  uint32_t GetFlags() const override { return flags_; }
-  size_t GetFdCount() const override { return 0; }
-  gfx::Size GetSize() const override { return size_; }
-  gfx::BufferFormat GetBufferFormat() const override {
-    return ui::GetBufferFormatFromFourCCFormat(format_);
-  }
-  bool AreFdsValid() const override { return false; }
-  size_t GetNumPlanes() const override { return planes_.size(); }
-  int GetPlaneFd(size_t plane) const override {
-    NOTREACHED();
-    return -1;
-  }
-  int GetPlaneStride(size_t plane) const override {
-    DCHECK_LT(plane, planes_.size());
-    return planes_[plane].stride;
-  }
-  int GetPlaneOffset(size_t plane) const override {
-    DCHECK_LT(plane, planes_.size());
-    return planes_[plane].offset;
-  }
-  size_t GetPlaneSize(size_t plane) const override {
-    DCHECK_LT(plane, planes_.size());
-    return planes_[plane].size;
-  }
-  uint32_t GetPlaneHandle(size_t plane) const override {
-    DCHECK_LT(plane, planes_.size());
-    return handles_[plane];
-  }
-  uint32_t GetHandle() const override { return GetPlaneHandle(0); }
-  gfx::NativePixmapHandle ExportHandle() const override {
-    NOTIMPLEMENTED();
-    return gfx::NativePixmapHandle();
-  }
-
- private:
-  uint32_t format_ = 0;
-  uint64_t format_modifier_ = 0;
-  uint32_t flags_ = 0;
-  std::vector<base::ScopedFD> fds_;
-  gfx::Size size_;
-  std::vector<gfx::NativePixmapPlane> planes_;
-  std::vector<uint32_t> handles_;
-
-  DISALLOW_COPY_AND_ASSIGN(MockGbmBuffer);
-};
-
-}  // namespace
-
-MockGbmDevice::MockGbmDevice() {}
-
-MockGbmDevice::~MockGbmDevice() {}
-
-void MockGbmDevice::set_allocation_failure(bool should_fail_allocations) {
-  should_fail_allocations_ = should_fail_allocations;
-}
-
-std::unique_ptr<GbmBuffer> MockGbmDevice::CreateBuffer(uint32_t format,
-                                                       const gfx::Size& size,
-                                                       uint32_t flags) {
-  if (should_fail_allocations_)
-    return nullptr;
-
-  return CreateBufferWithModifiers(format, size, flags, {});
-}
-
-std::unique_ptr<GbmBuffer> MockGbmDevice::CreateBufferWithModifiers(
-    uint32_t format,
-    const gfx::Size& size,
-    uint32_t flags,
-    const std::vector<uint64_t>& modifiers) {
-  uint32_t bytes_per_pixel;
-  switch (format) {
-    case DRM_FORMAT_XRGB8888:
-    case DRM_FORMAT_ARGB8888:
-      bytes_per_pixel = 4;
-      break;
-    case DRM_FORMAT_UYVY:
-      bytes_per_pixel = 2;
-      break;
-    default:
-      NOTREACHED() << "Unsupported format: " << format;
-      return nullptr;
-  }
-
-  if (modifiers.size() > 1)
-    return nullptr;
-
-  uint64_t format_modifier =
-      modifiers.size() ? modifiers[0] : DRM_FORMAT_MOD_NONE;
-  switch (format_modifier) {
-    case DRM_FORMAT_MOD_NONE:
-    case I915_FORMAT_MOD_X_TILED:
-      break;
-    default:
-      NOTREACHED() << "Unsupported format modifier: " << format_modifier;
-      return nullptr;
-  }
-
-  uint32_t width = base::checked_cast<uint32_t>(size.width());
-  uint32_t height = base::checked_cast<uint32_t>(size.height());
-  uint32_t plane_stride = base::CheckMul(bytes_per_pixel, width).ValueOrDie();
-  uint32_t plane_size = base::CheckMul(plane_stride, height).ValueOrDie();
-  uint32_t plane_offset = 0;
-
-  std::vector<gfx::NativePixmapPlane> planes;
-  planes.push_back(gfx::NativePixmapPlane(plane_stride, plane_offset,
-                                          plane_size, format_modifier));
-  std::vector<uint32_t> handles;
-  handles.push_back(next_handle_++);
-
-  return std::make_unique<MockGbmBuffer>(format, flags, format_modifier, size,
-                                         std::move(planes), std::move(handles));
-}
-
-std::unique_ptr<GbmBuffer> MockGbmDevice::CreateBufferFromFds(
-    uint32_t format,
-    const gfx::Size& size,
-    std::vector<base::ScopedFD> fds,
-    const std::vector<gfx::NativePixmapPlane>& planes) {
-  NOTREACHED();
-  return nullptr;
-}
-
-}  // namespace ui

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

-// Copyright 2018 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_MOCK_GBM_DEVICE_H_
-#define UI_OZONE_PLATFORM_DRM_GPU_MOCK_GBM_DEVICE_H_
-
-#include "ui/ozone/common/linux/gbm_device.h"
-
-namespace ui {
-
-// The real DrmDevice makes actual DRM calls which we can't use in unit tests.
-class MockGbmDevice : public GbmDevice {
- public:
-  MockGbmDevice();
-  ~MockGbmDevice() override;
-
-  void set_allocation_failure(bool should_fail_allocations);
-
-  // GbmDevice:
-  std::unique_ptr<GbmBuffer> CreateBuffer(uint32_t format,
-                                          const gfx::Size& size,
-                                          uint32_t flags) override;
-  std::unique_ptr<GbmBuffer> CreateBufferWithModifiers(
-      uint32_t format,
-      const gfx::Size& size,
-      uint32_t flags,
-      const std::vector<uint64_t>& modifiers) override;
-  std::unique_ptr<GbmBuffer> CreateBufferFromFds(
-      uint32_t format,
-      const gfx::Size& size,
-      std::vector<base::ScopedFD> fds,
-      const std::vector<gfx::NativePixmapPlane>& planes) override;
-
- private:
-  uint32_t next_handle_ = 0;
-  bool should_fail_allocations_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(MockGbmDevice);
-};
-
-}  // namespace ui
-
-#endif  // UI_OZONE_PLATFORM_DRM_GPU_MOCK_GBM_DEVICE_H_

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

@@ -15,12 +15,12 @@
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_fence.h"
-#include "ui/ozone/common/linux/gbm_buffer.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_console_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_framebuffer.h"
+#include "ui/ozone/platform/drm/gpu/drm_framebuffer_generator.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 
@@ -96,7 +96,8 @@ CrtcController* GetCrtcController(HardwareDisplayController* controller,
 
 }  // namespace
 
-ScreenManager::ScreenManager() {}
+ScreenManager::ScreenManager(DrmFramebufferGenerator* buffer_generator)
+    : buffer_generator_(buffer_generator) {}
 
 ScreenManager::~ScreenManager() {
   DCHECK(window_map_.empty());
@@ -386,11 +387,8 @@ DrmOverlayPlane ScreenManager::GetModesetBuffer(
   }
 
   scoped_refptr<DrmDevice> drm = controller->GetDrmDevice();
-  std::unique_ptr<GbmBuffer> buffer =
-      drm->gbm_device()->CreateBufferWithModifiers(
-          fourcc_format, bounds.size(), GBM_BO_USE_SCANOUT, modifiers);
-  scoped_refptr<DrmFramebuffer> framebuffer =
-      DrmFramebuffer::AddFramebuffer(drm, buffer.get());
+  scoped_refptr<DrmFramebuffer> buffer =
+      buffer_generator_->Create(drm, fourcc_format, modifiers, bounds.size());
   if (!buffer) {
     LOG(ERROR) << "Failed to create scanout buffer";
     return DrmOverlayPlane(nullptr, 0, gfx::OVERLAY_TRANSFORM_INVALID,
@@ -398,8 +396,8 @@ DrmOverlayPlane ScreenManager::GetModesetBuffer(
                            /* gpu_fence */ nullptr);
   }
 
-  FillModesetBuffer(drm, controller, framebuffer.get());
-  return DrmOverlayPlane(framebuffer, nullptr);
+  FillModesetBuffer(drm, controller, buffer.get());
+  return DrmOverlayPlane(buffer, nullptr);
 }
 
 bool ScreenManager::EnableController(HardwareDisplayController* controller) {

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

@@ -25,11 +25,12 @@ namespace ui {
 
 class DrmDevice;
 class DrmWindow;
+class DrmFramebufferGenerator;
 
 // Responsible for keeping track of active displays and configuring them.
 class ScreenManager {
  public:
-  ScreenManager();
+  ScreenManager(DrmFramebufferGenerator* surface_generator);
   virtual ~ScreenManager();
 
   // Register a display controller. This must be called before trying to
@@ -130,6 +131,7 @@ class ScreenManager {
 
   DrmWindow* FindWindowAt(const gfx::Rect& bounds) const;
 
+  DrmFramebufferGenerator* buffer_generator_;  // Not owned.
   // List of display controllers (active and disabled).
   HardwareDisplayControllers controllers_;
 

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

@@ -12,7 +12,6 @@
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/gpu_fence.h"
-#include "ui/ozone/common/linux/gbm_buffer.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"
@@ -20,7 +19,7 @@
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_controller.h"
 #include "ui/ozone/platform/drm/gpu/mock_drm_device.h"
-#include "ui/ozone/platform/drm/gpu/mock_gbm_device.h"
+#include "ui/ozone/platform/drm/gpu/mock_drm_framebuffer_generator.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 
 namespace ui {
@@ -57,36 +56,20 @@ class ScreenManagerTest : public testing::Test {
   }
 
   void SetUp() override {
-    auto gbm = std::make_unique<ui::MockGbmDevice>();
-    drm_ = new ui::MockDrmDevice(std::move(gbm));
+    drm_ = new ui::MockDrmDevice;
     device_manager_.reset(new ui::DrmDeviceManager(nullptr));
-    screen_manager_.reset(new ui::ScreenManager());
+    buffer_generator_.reset(new ui::MockDrmFramebufferGenerator());
+    screen_manager_.reset(new ui::ScreenManager(buffer_generator_.get()));
   }
   void TearDown() override {
     screen_manager_.reset();
     drm_ = nullptr;
   }
 
-  scoped_refptr<DrmFramebuffer> CreateBuffer(uint32_t format,
-                                             const gfx::Size& size) {
-    return CreateBufferWithModifier(format, DRM_FORMAT_MOD_NONE, size);
-  }
-
-  scoped_refptr<DrmFramebuffer> CreateBufferWithModifier(
-      uint32_t format,
-      uint64_t format_modifier,
-      const gfx::Size& size) {
-    std::vector<uint64_t> modifiers;
-    if (format_modifier != DRM_FORMAT_MOD_NONE)
-      modifiers.push_back(format_modifier);
-    auto buffer = drm_->gbm_device()->CreateBufferWithModifiers(
-        format, size, GBM_BO_USE_SCANOUT, modifiers);
-    return DrmFramebuffer::AddFramebuffer(drm_, buffer.get());
-  }
-
  protected:
   scoped_refptr<ui::MockDrmDevice> drm_;
   std::unique_ptr<ui::DrmDeviceManager> device_manager_;
+  std::unique_ptr<ui::MockDrmFramebufferGenerator> buffer_generator_;
   std::unique_ptr<ui::ScreenManager> screen_manager_;
 
  private:
@@ -377,9 +360,7 @@ TEST_F(ScreenManagerTest, CheckMirrorModeAfterBeginReEnabled) {
 
 TEST_F(ScreenManagerTest,
        CheckProperConfigurationWithDifferentDeviceAndSameCrtc) {
-  auto gbm_device = std::make_unique<ui::MockGbmDevice>();
-  scoped_refptr<ui::MockDrmDevice> drm2 =
-      new ui::MockDrmDevice(std::move(gbm_device));
+  scoped_refptr<ui::MockDrmDevice> drm2 = new ui::MockDrmDevice;
 
   screen_manager_->AddDisplayController(drm_, kPrimaryCrtc, kPrimaryConnector);
   screen_manager_->AddDisplayController(drm2, kPrimaryCrtc, kPrimaryConnector);
@@ -404,7 +385,7 @@ TEST_F(ScreenManagerTest,
 TEST_F(ScreenManagerTest, CheckControllerToWindowMappingWithSameBounds) {
   std::unique_ptr<ui::DrmWindow> window(
       new ui::DrmWindow(1, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(GetPrimaryBounds());
   screen_manager_->AddWindow(1, std::move(window));
 
@@ -422,7 +403,7 @@ TEST_F(ScreenManagerTest, CheckControllerToWindowMappingWithSameBounds) {
 TEST_F(ScreenManagerTest, CheckControllerToWindowMappingWithDifferentBounds) {
   std::unique_ptr<ui::DrmWindow> window(
       new ui::DrmWindow(1, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   gfx::Rect new_bounds = GetPrimaryBounds();
   new_bounds.Inset(0, 0, 1, 1);
   window->SetBounds(new_bounds);
@@ -445,7 +426,7 @@ TEST_F(ScreenManagerTest,
   for (size_t i = 1; i < kWindowCount + 1; ++i) {
     std::unique_ptr<ui::DrmWindow> window(
         new ui::DrmWindow(i, device_manager_.get(), screen_manager_.get()));
-    window->Initialize();
+    window->Initialize(buffer_generator_.get());
     window->SetBounds(GetPrimaryBounds());
     screen_manager_->AddWindow(i, std::move(window));
   }
@@ -470,7 +451,7 @@ TEST_F(ScreenManagerTest, ShouldDissociateWindowOnControllerRemoval) {
   gfx::AcceleratedWidget window_id = 1;
   std::unique_ptr<ui::DrmWindow> window(new ui::DrmWindow(
       window_id, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(GetPrimaryBounds());
   screen_manager_->AddWindow(window_id, std::move(window));
 
@@ -492,7 +473,7 @@ TEST_F(ScreenManagerTest, ShouldDissociateWindowOnControllerRemoval) {
 TEST_F(ScreenManagerTest, EnableControllerWhenWindowHasNoBuffer) {
   std::unique_ptr<ui::DrmWindow> window(
       new ui::DrmWindow(1, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(GetPrimaryBounds());
   screen_manager_->AddWindow(1, std::move(window));
 
@@ -521,10 +502,11 @@ TEST_F(ScreenManagerTest, EnableControllerWhenWindowHasNoBuffer) {
 TEST_F(ScreenManagerTest, EnableControllerWhenWindowHasBuffer) {
   std::unique_ptr<ui::DrmWindow> window(
       new ui::DrmWindow(1, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(GetPrimaryBounds());
-  scoped_refptr<DrmFramebuffer> buffer =
-      CreateBuffer(DRM_FORMAT_XRGB8888, GetPrimaryBounds().size());
+
+  scoped_refptr<ui::DrmFramebuffer> buffer = buffer_generator_->Create(
+      drm_, DRM_FORMAT_XRGB8888, {}, GetPrimaryBounds().size());
   ui::DrmOverlayPlaneList planes;
   planes.push_back(ui::DrmOverlayPlane(buffer, nullptr));
   window->SchedulePageFlip(std::move(planes), base::DoNothing(),
@@ -546,10 +528,13 @@ TEST_F(ScreenManagerTest, EnableControllerWhenWindowHasBuffer) {
 TEST_F(ScreenManagerTest, DISABLED_RejectBufferWithIncompatibleModifiers) {
   std::unique_ptr<ui::DrmWindow> window(
       new ui::DrmWindow(1, device_manager_.get(), screen_manager_.get()));
-  window->Initialize();
+  window->Initialize(buffer_generator_.get());
   window->SetBounds(GetPrimaryBounds());
-  auto buffer = CreateBufferWithModifier(
-      DRM_FORMAT_XRGB8888, I915_FORMAT_MOD_X_TILED, GetPrimaryBounds().size());
+  scoped_refptr<ui::DrmFramebuffer> buffer =
+      buffer_generator_->CreateWithModifier(drm_, DRM_FORMAT_XRGB8888,
+                                            I915_FORMAT_MOD_X_TILED,
+                                            GetPrimaryBounds().size());
+
   ui::DrmOverlayPlaneList planes;
   planes.push_back(ui::DrmOverlayPlane(buffer, nullptr));
   window->SchedulePageFlip(std::move(planes), base::DoNothing(),
@@ -573,14 +558,11 @@ TEST_F(ScreenManagerTest, DISABLED_RejectBufferWithIncompatibleModifiers) {
 }
 
 TEST(ScreenManagerTest2, ShouldNotHardwareMirrorDifferentDrmDevices) {
-  auto gbm_device1 = std::make_unique<MockGbmDevice>();
-  auto drm_device1 =
-      base::MakeRefCounted<MockDrmDevice>(std::move(gbm_device1));
-  auto gbm_device2 = std::make_unique<MockGbmDevice>();
-  auto drm_device2 =
-      base::MakeRefCounted<MockDrmDevice>(std::move(gbm_device2));
+  auto drm_device1 = base::MakeRefCounted<MockDrmDevice>();
+  auto drm_device2 = base::MakeRefCounted<MockDrmDevice>();
   DrmDeviceManager drm_device_manager(nullptr);
-  ScreenManager screen_manager;
+  MockDrmFramebufferGenerator buffer_generator;
+  ScreenManager screen_manager(&buffer_generator);
 
   constexpr uint32_t kCrtc19 = 19;
   constexpr uint32_t kConnector28 = 28;
@@ -599,7 +581,7 @@ TEST(ScreenManagerTest2, ShouldNotHardwareMirrorDifferentDrmDevices) {
   {
     auto window1 =
         std::make_unique<DrmWindow>(1, &drm_device_manager, &screen_manager);
-    window1->Initialize();
+    window1->Initialize(&buffer_generator);
     screen_manager.AddWindow(1, std::move(window1));
     screen_manager.GetWindow(1)->SetBounds(gfx::Rect(0, 0, 1920, 1080));
     screen_manager.AddDisplayController(drm_device1, kCrtc19, kConnector28);
@@ -611,7 +593,7 @@ TEST(ScreenManagerTest2, ShouldNotHardwareMirrorDifferentDrmDevices) {
                                               Mode(1920, 1080));
     auto window2 =
         std::make_unique<DrmWindow>(2, &drm_device_manager, &screen_manager);
-    window2->Initialize();
+    window2->Initialize(&buffer_generator);
     screen_manager.AddWindow(2, std::move(window2));
     screen_manager.GetWindow(2)->SetBounds(gfx::Rect(0, 1140, 1920, 1080));
   }
@@ -657,7 +639,7 @@ TEST(ScreenManagerTest2, ShouldNotHardwareMirrorDifferentDrmDevices) {
                                               Mode(1920, 1080));
     auto window3 =
         std::make_unique<DrmWindow>(3, &drm_device_manager, &screen_manager);
-    window3->Initialize();
+    window3->Initialize(&buffer_generator);
     screen_manager.AddWindow(3, std::move(window3));
     screen_manager.GetWindow(3)->SetBounds(gfx::Rect(0, 0, 1920, 1080));
     screen_manager.GetWindow(1)->SetBounds(gfx::Rect(0, 1140, 1920, 1080));