ozone: Create GbmBuffers from fourcc formats and gbm flags.

ui/ozone/platform/drm/gpu/drm_thread.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/drm_thread.h"
 
+#include <gbm.h>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/service_manager/public/cpp/connection.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"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.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"
 #include "ui/ozone/platform/drm/gpu/gbm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/gbm_device.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
 #include "ui/ozone/platform/drm/gpu/proxy_helpers.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/ozone_switches.h"
 
 namespace ui {
 
 namespace {
 
 class GbmBufferGenerator : public ScanoutBufferGenerator {
  public:
   GbmBufferGenerator() {}
   ~GbmBufferGenerator() override {}
 
   // ScanoutBufferGenerator:
   scoped_refptr<ScanoutBuffer> Create(const scoped_refptr<DrmDevice>& drm,
-                                      gfx::BufferFormat format,
+                                      uint32_t format,
                                       const gfx::Size& size) override {
     scoped_refptr<GbmDevice> gbm(static_cast<GbmDevice*>(drm.get()));
     return GbmBuffer::CreateBuffer(gbm, format, size,
-                                   gfx::BufferUsage::SCANOUT);
+                                   GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR);
   }
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(GbmBufferGenerator);
 };
 
 class GbmDeviceGenerator : public DrmDeviceGenerator {
  public:
   GbmDeviceGenerator(bool use_atomic) : use_atomic_(use_atomic) {}
   ~GbmDeviceGenerator() override {}
@@ skipping 48 matching lines @@
 }
 
 void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
                              const gfx::Size& size,
                              gfx::BufferFormat format,
                              gfx::BufferUsage usage,
                              scoped_refptr<GbmBuffer>* buffer) {
   scoped_refptr<GbmDevice> gbm =
       static_cast<GbmDevice*>(device_manager_->GetDrmDevice(widget).get());
   DCHECK(gbm);
-  *buffer = GbmBuffer::CreateBuffer(gbm, format, size, usage);
+
+  uint32_t flags = 0;
+  switch (usage) {
+    case gfx::BufferUsage::GPU_READ:
+      break;
+    case gfx::BufferUsage::SCANOUT:
+      flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;
+      break;
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
+    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
+      flags = GBM_BO_USE_LINEAR;
+      break;
+  }
+
+  *buffer = GbmBuffer::CreateBuffer(
+      gbm, ui::GetFourCCFormatFromBufferFormat(format), size, flags);
 }
 
 void DrmThread::CreateBufferFromFds(
     gfx::AcceleratedWidget widget,
     const gfx::Size& size,
     gfx::BufferFormat format,
     std::vector<base::ScopedFD>&& fds,
     const std::vector<gfx::NativePixmapPlane>& planes,
     scoped_refptr<GbmBuffer>* buffer) {
   scoped_refptr<GbmDevice> gbm =
       static_cast<GbmDevice*>(device_manager_->GetDrmDevice(widget).get());
   DCHECK(gbm);
-  *buffer =
-      GbmBuffer::CreateBufferFromFds(gbm, format, size, std::move(fds), planes);
+  *buffer = GbmBuffer::CreateBufferFromFds(
+      gbm, ui::GetFourCCFormatFromBufferFormat(format), size, std::move(fds),
+      planes);
 }
 
 void DrmThread::GetScanoutFormats(
     gfx::AcceleratedWidget widget,
     std::vector<gfx::BufferFormat>* scanout_formats) {
   display_manager_->GetScanoutFormats(widget, scanout_formats);
 }
 
 void DrmThread::SchedulePageFlip(gfx::AcceleratedWidget widget,
                                  const std::vector<OverlayPlane>& planes,
@@ skipping 119 matching lines @@
                                        correction_matrix);
 }
 
 // DrmThread requires a BindingSet instead of a simple Binding because it will
 // be used from multiple threads in multiple processes.
 void DrmThread::AddBinding(ozone::mojom::DeviceCursorRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace ui