ozone: Create GbmBuffers from fourcc formats and gbm flags.

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

Index: ui/ozone/platform/drm/gpu/drm_thread.cc
diff --git a/ui/ozone/platform/drm/gpu/drm_thread.cc b/ui/ozone/platform/drm/gpu/drm_thread.cc
index c323227514f78b9e5280673652cd119ed9260726..c54e992f66126c9d7d6c130b619c5c10ea0b3cba 100644
--- a/ui/ozone/platform/drm/gpu/drm_thread.cc
+++ b/ui/ozone/platform/drm/gpu/drm_thread.cc
@@ -4,6 +4,7 @@
 
 #include "ui/ozone/platform/drm/gpu/drm_thread.h"
 
+#include <gbm.h>
 #include <utility>
 
 #include "base/command_line.h"
@@ -11,6 +12,7 @@
 #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"
@@ -35,11 +37,11 @@ class GbmBufferGenerator : public ScanoutBufferGenerator {
 
   // 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);

[tfiga, 2016/12/06 06:16:32]

Why GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR? First of all, GBM_BO_USE_RENDERING
should be necessary for the GPU to actually write anything to this buffer. Then
some platforms (e.g. Intel) can actually scan out of tiled buffers, which is a
significant performance optimization, so forcing linear doesn't make much sense.

[Daniele Castagna, 2016/12/06 06:31:01]

The GPU is not writing to this buffer. We're mapping it and writing to it via SW
skia.

I don't think we care about performance in this case, this allocation is for
buffers that are used only for modesetting after we change the display mode.

[tfiga, 2016/12/06 06:50:57]

Acknowledged.

[marcheu1, 2016/12/13 00:07:06]

This is still wrong. You can't allocate a gem BO and expect to be able to map it
like a dumb buffer since these are two different things. There are two possible
ways to make this consistent:

1. allocate an actual dumb buffer with DRM_IOCTL_MODE_CREATE_DUMB (not through
gbm), then map it like a dumb buffer (which is what the code currently does).

2. allocate a GBM buffer with the LINEAR flag. In theory the LINEAR flag is not
needed because gbm_bo_map() gives you a linear view, except on Tegra where
that's not working because nvidia didn't implement it, and on Kevin where that
might not work because we don't know how to decompress AFBC. You need to then
change the code which maps the buffer to use gbm_bo_map() instead of
DRM_IOCTL_MODE_MAP_DUMB.

[Daniele Castagna, 2016/12/13 02:28:59]

As discussed offline, let's start landing crrev.com/2568243004 as a temporary
fix for the regression described in crbug.com/673026

   }
 
  protected:
@@ -108,7 +110,22 @@ void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
   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(
@@ -121,8 +138,9 @@ void DrmThread::CreateBufferFromFds(
   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(