ozone: Implement zero/one-copy texture for Ozone GBM.

content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.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 "content/common/gpu/gpu_memory_buffer_factory_ozone_native_pixmap.h"
 
+#include "base/posix/eintr_wrapper.h"
 #include "ui/gl/gl_image_ozone_native_pixmap.h"
 #include "ui/ozone/public/client_native_pixmap_factory.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace content {
 namespace {
 
 void GetSupportedConfigurations(
     std::vector<GpuMemoryBufferFactory::Configuration>* configurations) {
   std::vector<ui::ClientNativePixmapFactory::Configuration>
       native_pixmap_configurations =
           ui::ClientNativePixmapFactory::GetInstance()
               ->GetSupportedConfigurations();
   for (auto& native_pixmap_configuration : native_pixmap_configurations) {
     configurations->push_back({native_pixmap_configuration.format,
                                native_pixmap_configuration.usage});
   }
 }
 
+bool ShareToClientProcess(int fd, base::FileDescriptor* new_handle) {
+  int duped_handle = HANDLE_EINTR(dup(fd));
+  if (duped_handle < 0) {
+    DPLOG(ERROR) << "dup() failed.";
+    *new_handle = base::FileDescriptor();
+    return false;
+  }
+
+  *new_handle = base::FileDescriptor(duped_handle, true);
+  return true;
+}
+
 }  // namespace
 
 GpuMemoryBufferFactoryOzoneNativePixmap::
     GpuMemoryBufferFactoryOzoneNativePixmap() {}
 
 GpuMemoryBufferFactoryOzoneNativePixmap::
     ~GpuMemoryBufferFactoryOzoneNativePixmap() {}
 
 // static
 bool GpuMemoryBufferFactoryOzoneNativePixmap::
@@ skipping 35 matching lines @@
   }
   base::AutoLock lock(native_pixmaps_lock_);
   NativePixmapMapKey key(id, client_id);
   DCHECK(native_pixmaps_.find(key) == native_pixmaps_.end())
       << "pixmap with this key must not exist";
   native_pixmaps_[key] = pixmap;
 
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::OZONE_NATIVE_PIXMAP;
   handle.id = id;
+  if (usage == gfx::BufferUsage::MAP) {
+    base::FileDescriptor dma_buf;
+    if (!ShareToClientProcess(pixmap->GetDmaBufFd(), &dma_buf)) {
+      DLOG(ERROR) << "Fail to duplicate a DMA-BUF file descriptor";
+      return gfx::GpuMemoryBufferHandle();
+    }
+    handle.handle = dma_buf;
+  }
   return handle;
 }
 
 void GpuMemoryBufferFactoryOzoneNativePixmap::DestroyGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int client_id) {
   base::AutoLock lock(native_pixmaps_lock_);
   auto it = native_pixmaps_.find(NativePixmapMapKey(id, client_id));
   DCHECK(it != native_pixmaps_.end()) << "pixmap with this key must exist";
   native_pixmaps_.erase(it);
@@ skipping 25 matching lines @@
   scoped_refptr<gfx::GLImageOzoneNativePixmap> image(
       new gfx::GLImageOzoneNativePixmap(size, internalformat));
   if (!image->Initialize(pixmap.get(), format)) {
     LOG(ERROR) << "Failed to create GLImage";
     return nullptr;
   }
   return image;
 }
 
 }  // namespace content