Add ClientNativePixmap multi-planar support.

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>
@@ skipping 57 matching lines @@
 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_;
 }
@@ skipping 28 matching lines @@
   std::vector<base::ScopedFD> fds;
   std::vector<gfx::NativePixmapPlane> planes;
 
   DCHECK_EQ(gbm_bo_get_num_planes(bo),
             gfx::NumberOfPlanesForBufferFormat(format));
   for (size_t i = 0; i < gfx::NumberOfPlanesForBufferFormat(format); ++i) {
     // The fd returned by gbm_bo_get_fd is not ref-counted and need to be
     // kept open for the lifetime of the buffer.
     base::ScopedFD fd(gbm_bo_get_plane_fd(bo, i));
 
-    if (!fd.is_valid()) {
-      PLOG(ERROR) << "Failed to export buffer to dma_buf";
-      gbm_bo_destroy(bo);
-      return nullptr;
+    // TODO(dcastagna): support multiple fds.
+    // crbug.com/642410
+    if (!i) {
+      if (!fd.is_valid()) {
+        PLOG(ERROR) << "Failed to export buffer to dma_buf";
+        gbm_bo_destroy(bo);
+        return nullptr;
+      }
+      fds.emplace_back(std::move(fd));
     }
-    fds.emplace_back(std::move(fd));
 
-    planes.emplace_back(gbm_bo_get_plane_stride(bo, i),
-                        gbm_bo_get_plane_offset(bo, i),
-                        gbm_bo_get_plane_format_modifier(bo, i));
+    planes.emplace_back(
+        gbm_bo_get_plane_stride(bo, i), gbm_bo_get_plane_offset(bo, i),
+        gbm_bo_get_plane_size(bo, i), gbm_bo_get_plane_format_modifier(bo, i));
   }
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(
       gbm, bo, format, usage, std::move(fds), size, std::move(planes)));
   if (usage == gfx::BufferUsage::SCANOUT && !buffer->GetFramebufferId())
     return nullptr;
 
   return buffer;
 }
 
 // static
@@ skipping 63 matching lines @@
     if (i < buffer_->GetFdCount()) {
       base::ScopedFD scoped_fd(HANDLE_EINTR(dup(buffer_->GetFd(i))));
       if (!scoped_fd.is_valid()) {
         PLOG(ERROR) << "dup";
         return gfx::NativePixmapHandle();
       }
       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(i));
   }
   return handle;
 }
 
 GbmPixmap::~GbmPixmap() {
 }
 
 void* GbmPixmap::GetEGLClientBuffer() const {
   return nullptr;
@@ skipping 73 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