Add NativePixmapDmabufStub to finalize glCreateImageCHROMIUM on Linux.

ui/ozone/platform/drm/gpu/gbm_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/ozone/platform/drm/gpu/gbm_buffer.h"
 
 #include <drm.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <xf86drm.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/geometry/size_conversions.h"
-#include "ui/gfx/native_pixmap_handle.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.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/gbm_surfaceless.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace ui {
 
 GbmBuffer::GbmBuffer(const scoped_refptr<GbmDevice>& gbm,
                      gbm_bo* bo,
                      uint32_t format,
                      uint32_t flags,
                      uint64_t modifier,
                      uint32_t addfb_flags,
                      std::vector<base::ScopedFD>&& fds,
                      const gfx::Size& size,
-
                      const std::vector<gfx::NativePixmapPlane>&& planes)
     : GbmBufferBase(gbm, bo, format, flags, modifier, addfb_flags),
       format_(format),
       flags_(flags),
-      fds_(std::move(fds)),
       size_(size),
-      planes_(std::move(planes)) {}
+      helper_(new gfx::NativePixmapDmabufHelper(std::move(fds),
+                                                std::move(planes))) {}
 
 GbmBuffer::~GbmBuffer() {
   if (bo())
     gbm_bo_destroy(bo());
 }
 
 bool GbmBuffer::AreFdsValid() const {
-  if (fds_.empty())
-    return false;
-
-  for (const auto& fd : fds_) {
-    if (fd.get() == -1)
-      return false;
-  }
-  return true;
+  return helper_->AreFdsValid();
 }
 
 size_t GbmBuffer::GetFdCount() const {
-  return fds_.size();
+  return helper_->GetFdCount();
 }
 
 int GbmBuffer::GetFd(size_t index) const {
-  DCHECK_LT(index, fds_.size());
-  return fds_[index].get();
+  return helper_->GetFd(index);
 }
 
 int GbmBuffer::GetStride(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].stride;
+  return helper_->GetStride(index);
 }
 
 int GbmBuffer::GetOffset(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].offset;
+  return helper_->GetOffset(index);
 }
 
 size_t GbmBuffer::GetSize(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].size;
+  return helper_->GetSize(index);
 }
 
 // TODO(reveman): This should not be needed once crbug.com/597932 is fixed,
 // as the size would be queried directly from the underlying bo.
 gfx::Size GbmBuffer::GetSize() const {
   return size_;
 }
 
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBufferForBO(
     const scoped_refptr<GbmDevice>& gbm,
@@ skipping 117 matching lines @@
   if (try_scanout)
     flags |= GBM_BO_USE_SCANOUT;
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(
       gbm, bo, format, flags, 0, 0, std::move(fds), size, std::move(planes)));
 
   return buffer;
 }
 
 GbmPixmap::GbmPixmap(GbmSurfaceFactory* surface_manager,
                      const scoped_refptr<GbmBuffer>& buffer)
-    : surface_manager_(surface_manager), buffer_(buffer) {}
+    : NativePixmapDmaBuf(
+          buffer->GetSize(),
+          ui::GetBufferFormatFromFourCCFormat(buffer->GetFormat()),
+          buffer->helper()),
+      surface_manager_(surface_manager),
+      buffer_(buffer) {}
+
+GbmPixmap::~GbmPixmap() {}
+
+uint64_t GbmPixmap::GetDmaBufModifier(size_t plane) const {
+  return buffer_->GetFormatModifier();
+}
+
+bool GbmPixmap::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                                     int plane_z_order,
+                                     gfx::OverlayTransform plane_transform,
+                                     const gfx::Rect& display_bounds,
+                                     const gfx::RectF& crop_rect) {
+  DCHECK(buffer_->GetFlags() & GBM_BO_USE_SCANOUT);
+  OverlayPlane::ProcessBufferCallback processing_callback;
+  if (!processing_callback_.is_null())
+    processing_callback = base::Bind(&GbmPixmap::ProcessBuffer, this);
+
+  surface_manager_->GetSurface(widget)->QueueOverlayPlane(
+      OverlayPlane(buffer_, plane_z_order, plane_transform, display_bounds,
+                   crop_rect, processing_callback));
+
+  return true;
+}
 
 void GbmPixmap::SetProcessingCallback(
     const ProcessingCallback& processing_callback) {
   DCHECK(processing_callback_.is_null());
   processing_callback_ = processing_callback;
 }
 
 gfx::NativePixmapHandle GbmPixmap::ExportHandle() {
   gfx::NativePixmapHandle handle;
   gfx::BufferFormat format =
@@ skipping 11 matching lines @@
       handle.fds.emplace_back(
           base::FileDescriptor(scoped_fd.release(), true /* auto_close */));
     }
     handle.planes.emplace_back(buffer_->GetStride(i), buffer_->GetOffset(i),
                                buffer_->GetSize(i),
                                buffer_->GetFormatModifier());
   }
   return handle;
 }
 
-GbmPixmap::~GbmPixmap() {
-}
-
-void* GbmPixmap::GetEGLClientBuffer() const {
-  return nullptr;
-}
-
-bool GbmPixmap::AreDmaBufFdsValid() const {
-  return buffer_->AreFdsValid();
-}
-
-size_t GbmPixmap::GetDmaBufFdCount() const {
-  return buffer_->GetFdCount();
-}
-
-int GbmPixmap::GetDmaBufFd(size_t plane) const {
-  return buffer_->GetFd(plane);
-}
-
-int GbmPixmap::GetDmaBufPitch(size_t plane) const {
-  return buffer_->GetStride(plane);
-}
-
-int GbmPixmap::GetDmaBufOffset(size_t plane) const {
-  return buffer_->GetOffset(plane);
-}
-
-uint64_t GbmPixmap::GetDmaBufModifier(size_t plane) const {
-  return buffer_->GetFormatModifier();
-}
-
-gfx::BufferFormat GbmPixmap::GetBufferFormat() const {
-  return ui::GetBufferFormatFromFourCCFormat(buffer_->GetFormat());
-}
-
-gfx::Size GbmPixmap::GetBufferSize() const {
-  return buffer_->GetSize();
-}
-
-bool GbmPixmap::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                     int plane_z_order,
-                                     gfx::OverlayTransform plane_transform,
-                                     const gfx::Rect& display_bounds,
-                                     const gfx::RectF& crop_rect) {
-  DCHECK(buffer_->GetFlags() & GBM_BO_USE_SCANOUT);
-  OverlayPlane::ProcessBufferCallback processing_callback;
-  if (!processing_callback_.is_null())
-    processing_callback = base::Bind(&GbmPixmap::ProcessBuffer, this);
-
-  surface_manager_->GetSurface(widget)->QueueOverlayPlane(
-      OverlayPlane(buffer_, plane_z_order, plane_transform, display_bounds,
-                   crop_rect, processing_callback));
-
-  return true;
-}
-
 scoped_refptr<ScanoutBuffer> GbmPixmap::ProcessBuffer(const gfx::Size& size,
                                                       uint32_t format) {
   DCHECK(GetBufferSize() != size ||
          buffer_->GetFramebufferPixelFormat() != format);
 
   if (!processed_pixmap_ || size != processed_pixmap_->GetBufferSize() ||
       format != processed_pixmap_->buffer()->GetFramebufferPixelFormat()) {
     // Release any old processed pixmap.
     processed_pixmap_ = nullptr;
     scoped_refptr<GbmBuffer> buffer = GbmBuffer::CreateBuffer(
@@ skipping 10 matching lines @@
   DCHECK(!processing_callback_.is_null());
   if (!processing_callback_.Run(this, processed_pixmap_)) {
     LOG(ERROR) << "Failed processing NativePixmap";
     return nullptr;
   }
 
   return processed_pixmap_->buffer();
 }
 
 }  // namespace ui