Change CHROMIUM_image declarations to support multi planar input.

content/common/gpu/gpu_channel.cc

Index: content/common/gpu/gpu_channel.cc
diff --git a/content/common/gpu/gpu_channel.cc b/content/common/gpu/gpu_channel.cc
index c12c762c6004f725973182513535274cc6ac2cc7..e6463b4cb3a3c7f79b4833b0595ff2ffc924e191 100644
--- a/content/common/gpu/gpu_channel.cc
+++ b/content/common/gpu/gpu_channel.cc
@@ -827,18 +827,39 @@ uint64 GpuChannel::GetMemoryUsage() {
   return size;
 }
 
-scoped_refptr<gfx::GLImage> GpuChannel::CreateImageForGpuMemoryBuffer(
-    const gfx::GpuMemoryBufferHandle& handle,
+scoped_refptr<gfx::GLImage> GpuChannel::CreateImageForGpuMemoryBuffers(
+    const std::vector<gfx::GpuMemoryBufferHandle>& handles,
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
+    const std::vector<gfx::GpuMemoryBuffer::Format>& formats,
     uint32 internalformat) {
-  switch (handle.type) {
+  size_t num_buffers =

[reveman, 2015/03/18 16:59:01]

num_buffers = IsImageFormatSupported, that doesn't look right. Is this supposed
to use NumberOfPlanesForImageFormat?

[emircan, 2015/03/18 23:51:26]

Done.

+      gpu::ImageFactory::IsImageFormatSupported(internalformat);
+
+  // Make sure that the gives vectors have the correct size.
+  DCHECK_EQ(handles.size(), num_buffers);
+  DCHECK_EQ(formats.size(), num_buffers);
+
+  // Check if all the handle types are equal, and if they aren't, return an
+  // empty image.
+  gfx::GpuMemoryBufferType handle_type = handles[0].type;
+  for (size_t i = 1; i < num_buffers; ++i) {
+    if (handles[i].type != handle_type)
+      return scoped_refptr<gfx::GLImage>();
+  }

[reveman, 2015/03/18 16:59:01]

We could do this in a more C++-ish way with something like:

if (std::find_if(handles.begin(), handles.end(),     
                 [handles](const gfx::GpuMemoryBufferHandle& handle) {         
                     return handle.type != handles[0].type;                     
    
                 }) != handles.end())
  return scoped_refptr<gfx::GLImage>();

not sure that's cleaner. up to you.

[emircan, 2015/03/18 23:51:26]

Acknowledged.

I agree it looks better with find_if. However, performance-wise the current
would be better, considering that most use case is still with single buffer. 

+
+  switch (handle_type) {
     case gfx::SHARED_MEMORY_BUFFER: {
+      // TODO(emircan): See http://crbug.com/439520; support passing multiple
+      // buffers when new multi-planar formats are added.

[reveman, 2015/03/18 16:59:01]

I think you can remove this comment as it's not clear that SHARED_MEMORY_BUFFER
will ever support multi-plane formats.

[emircan, 2015/03/18 23:51:26]

Done.

+      if (num_buffers != 1) {
+        NOTIMPLEMENTED();

[reveman, 2015/03/18 16:59:01]

I don't think we need NOTIMPLEMENTED here. Just a comment saying that
SHARED_MEMORY_BUFFER doesn't support multi-plane formats is enough.

[emircan, 2015/03/18 23:51:26]

Changed it to a DLOG(ERROR). Possible to make it a DVLOG() as well, but I wasn't
sure about the severity level.

+        return scoped_refptr<gfx::GLImage>();
+      }
+
       scoped_refptr<gfx::GLImageSharedMemory> image(
           new gfx::GLImageSharedMemory(size, internalformat));
-      if (!image->Initialize(handle, format))
+      if (!image->Initialize(handles[0], formats[0]))
         return scoped_refptr<gfx::GLImage>();
-
       return image;
     }
     default: {
@@ -848,11 +869,8 @@ scoped_refptr<gfx::GLImage> GpuChannel::CreateImageForGpuMemoryBuffer(
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
-          ->CreateImageForGpuMemoryBuffer(handle,
-                                          size,
-                                          format,
-                                          internalformat,
-                                          client_id_);
+          ->CreateImageForGpuMemoryBuffers(handles, size, formats,
+                                           internalformat, client_id_);
     }
   }
 }