ui: Add Linux dma-buf implementation of GLImage.

ui/gl/gl_image_linux_dma_buffer.cc

+// Copyright 2014 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/gl/gl_image_linux_dma_buffer.h"
+
+#include <unistd.h>
+
+#define FOURCC(a, b, c, d)                                    \
+  ((static_cast<uint32>(a)) | (static_cast<uint32>(b) << 8) | \
+   (static_cast<uint32>(c) << 16) | (static_cast<uint32>(d) << 24))
+
+#define DRM_FORMAT_ARGB8888 FOURCC('A', 'R', '2', '4')
+#define DRM_FORMAT_XRGB8888 FOURCC('X', 'R', '2', '4')
+
+namespace gfx {
+namespace {
+
+bool ValidFormat(unsigned internalformat, gfx::GpuMemoryBuffer::Format format) {
+  switch (internalformat) {
+    case GL_RGB:
+      switch (format) {
+        case gfx::GpuMemoryBuffer::RGBX_8888:

[alexst (slow to review), 2014/10/10 14:46:35]

I noticed you left plumbing for internal format here and in your big refactor.
Is there a particular reason you chose to keep it once the code leases the
command buffer?

I may have missed it in your big patch, but it seemed like
gfx::GpuMemoryBuffer::Format alone was sufficient once GL calls are processed.

[reveman, 2014/10/10 15:06:14]

I think it's better to explicitly express the internalformat of buffers when
introducing them to the GL rather than having that magically happen. This way
the client knows what to expect when sampling from a texture with a bound image.

It also allows us to potentially use a RGBA_8888 buffer with internalformat
GL_RGB and ignore the alpha channel.

+          return true;
+        case gfx::GpuMemoryBuffer::RGBA_8888:
+        case gfx::GpuMemoryBuffer::BGRA_8888:
+          return false;
+      }
+      NOTREACHED();
+      return false;
+    case GL_RGBA:
+      switch (format) {
+        case gfx::GpuMemoryBuffer::BGRA_8888:
+          return true;
+        case gfx::GpuMemoryBuffer::RGBX_8888:
+        case gfx::GpuMemoryBuffer::RGBA_8888:
+          return false;
+      }
+      NOTREACHED();
+      return false;
+    default:
+      return false;
+  }
+}
+
+EGLint FourCC(gfx::GpuMemoryBuffer::Format format) {
+  switch (format) {
+    case gfx::GpuMemoryBuffer::BGRA_8888:
+      return DRM_FORMAT_ARGB8888;
+    case gfx::GpuMemoryBuffer::RGBX_8888:
+      return DRM_FORMAT_XRGB8888;
+    case gfx::GpuMemoryBuffer::RGBA_8888:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
+
+bool IsHandleValid(const base::FileDescriptor& handle) {
+  return handle.fd >= 0;
+}
+
+}  // namespace
+
+GLImageLinuxDMABuffer::GLImageLinuxDMABuffer(const gfx::Size& size,
+                                             unsigned internalformat)
+    : GLImageEGL(size), internalformat_(internalformat) {
+}
+
+GLImageLinuxDMABuffer::~GLImageLinuxDMABuffer() {
+}
+
+bool GLImageLinuxDMABuffer::Initialize(const base::FileDescriptor& handle,

[piman, 2014/10/14 23:52:26]

Should this take ownership of the file descriptor, and close it (on
destruction?)

If not, what keeps ownership?

[reveman, 2014/10/15 00:48:07]

Ownership is not passed to this function. It is the responsibility of the caller
to close the file descriptor on success and failure. eglCreateImageKHR with
EGL_LINUX_DMA_BUF_EXT as target will dup the fd on success if I understand it
correctly. The comment below was supposed to make this clear but maybe it can be
improved?

Some discussion related to this earlier and I think there used to be a bug in
Mesa that prevented this from working correctly but it should be fixed now, I
think. fjhenigman, is this correct?

[piman, 2014/10/15 03:19:52]

I see... it was not evident at first. Maybe "the EGL will take a reference to
the dma_buf and the file descriptor can be closed." ?
Maybe move that comment to the header file?

[reveman, 2014/10/15 03:32:04]

Added a comment to the header. Kept the comment here too as it's more
implementation specific and explains why we don't have to explicitly dup the fd
here.

+                                       gfx::GpuMemoryBuffer::Format format,
+                                       int pitch) {
+  if (!ValidFormat(internalformat_, format)) {
+    LOG(ERROR) << "Invalid format: " << internalformat_;
+    return false;
+  }
+
+  if (!IsHandleValid(handle)) {
+    LOG(ERROR) << "Invalid file descriptor: " << handle.fd;
+    return false;
+  }
+
+  // Note: If eglCreateImageKHR is successful for a EGL_LINUX_DMA_BUF_EXT
+  // target, the EGL will take a reference to the dma_buf.
+  EGLint attrs[] = {EGL_WIDTH,
+                    size_.width(),
+                    EGL_HEIGHT,
+                    size_.height(),
+                    EGL_LINUX_DRM_FOURCC_EXT,
+                    FourCC(format),
+                    EGL_DMA_BUF_PLANE0_FD_EXT,
+                    handle.fd,
+                    EGL_DMA_BUF_PLANE0_OFFSET_EXT,
+                    0,
+                    EGL_DMA_BUF_PLANE0_PITCH_EXT,
+                    pitch,
+                    EGL_NONE};
+  return GLImageEGL::Initialize(
+      EGL_LINUX_DMA_BUF_EXT, static_cast<EGLClientBuffer>(NULL), attrs);
+}
+
+}  // namespace gfx