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),
+      NativePixmapDmabufHelper(std::move(fds), std::move(planes)),
       format_(format),
       flags_(flags),
-      fds_(std::move(fds)),
-      size_(size),
-      planes_(std::move(planes)) {}
+      size_(size) {}
 
 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;
-}
-
-size_t GbmBuffer::GetFdCount() const {
-  return fds_.size();
-}
-
-int GbmBuffer::GetFd(size_t index) const {
-  DCHECK_LT(index, fds_.size());
-  return fds_[index].get();
-}
-
-int GbmBuffer::GetStride(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].stride;
-}
-
-int GbmBuffer::GetOffset(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].offset;
-}
-
-size_t GbmBuffer::GetSize(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].size;
-}
-
-uint64_t GbmBuffer::GetFormatModifier(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].modifier;
-}
-
 // 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_;
 }
 
+size_t GbmBuffer::GetSize(size_t plane) const {
+  return gfx::NativePixmapDmabufHelper::GetSize(plane);
+}
+
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBufferForBO(
     const scoped_refptr<GbmDevice>& gbm,
     gbm_bo* bo,
     uint32_t format,
     const gfx::Size& size,
     uint32_t flags,
     uint64_t modifier,
     uint32_t addfb_flags) {
   if (!bo)
     return nullptr;
@@ skipping 109 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),
+      surface_manager_(surface_manager),
+      buffer_(buffer) {}
 
 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 14 matching lines @@
     handle.planes.emplace_back(buffer_->GetStride(i), buffer_->GetOffset(i),
                                buffer_->GetSize(i),
                                buffer_->GetFormatModifier(i));
   }
   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(plane);
-}
-
-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);
 
@@ skipping 27 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