Disable multi-planar import for now

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 148 matching lines @@
     std::vector<base::ScopedFD>&& fds,
     const std::vector<gfx::NativePixmapPlane>& planes) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBufferFromFD", "device",
                gbm->device_path().value(), "size", size.ToString());
   DCHECK_LE(fds.size(), planes.size());
   DCHECK_EQ(planes[0].offset, 0);
 
   uint32_t fourcc_format = GetFourCCFormatFromBufferFormat(format);
 
   // Use scanout if supported.
   bool use_scanout = gbm_device_is_format_supported(

[Daniele Castagna, 2016/11/05 00:21:33]

I was thinking of something like
bool use_scanout = is_support() && planes.size() == 1.

       gbm->device(), fourcc_format, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
 
   gbm_bo* bo = nullptr;
-  if (use_scanout) {
-    struct gbm_import_fd_planar_data fd_data {};
-    for (size_t i = 0; i < fds.size(); ++i)
-      fd_data.fds[i] = fds[i].get();
-
+  if (use_scanout && planes.size() == 1) {
+    struct gbm_import_fd_data fd_data;
+    fd_data.fd = fds[0].get();
     fd_data.width = size.width();
     fd_data.height = size.height();
+    fd_data.stride = planes[0].stride;
     fd_data.format = fourcc_format;
 
-    for (size_t i = 0; i < planes.size(); ++i) {
-      fd_data.strides[i] = planes[i].stride;
-      fd_data.offsets[i] = planes[i].offset;
-      fd_data.format_modifiers[i] = planes[i].modifier;
-    }
-
-    // The fds passed to gbm_bo_import are not ref-counted and need to be
+    // The fd passed to gbm_bo_import is not ref-counted and need to be
     // kept open for the lifetime of the buffer.
-    bo = gbm_bo_import(gbm->device(), GBM_BO_IMPORT_FD_PLANAR, &fd_data,
+    bo = gbm_bo_import(gbm->device(), GBM_BO_IMPORT_FD, &fd_data,
                        GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
     if (!bo) {
       LOG(ERROR) << "nullptr returned from gbm_bo_import";
       return nullptr;
     }
   }
 
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(
       gbm, bo, format,
       use_scanout ? gfx::BufferUsage::SCANOUT : gfx::BufferUsage::GPU_READ,
       std::move(fds), size, std::move(planes)));
   // If scanout support for buffer is expected then make sure we managed to
   // create a framebuffer for it as otherwise using it for scanout will fail.
   if (use_scanout && !buffer->GetFramebufferId())

[Daniele Castagna, 2016/11/05 00:18:35]

Wouldn't we hit this?

     return nullptr;
 
   return buffer;
 }
 
 GbmPixmap::GbmPixmap(GbmSurfaceFactory* surface_manager,
                      const scoped_refptr<GbmBuffer>& buffer)
     : surface_manager_(surface_manager), buffer_(buffer) {}
 
 void GbmPixmap::SetProcessingCallback(
@@ skipping 104 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