Change CHROMIUM_image declarations to support multi planar input.

content/common/gpu/gpu_channel.cc

 // Copyright (c) 2012 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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 809 matching lines @@
 
 uint64 GpuChannel::GetMemoryUsage() {
   uint64 size = 0;
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     size += it.GetCurrentValue()->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: {
       GpuChannelManager* manager = gpu_channel_manager();
       if (!manager->gpu_memory_buffer_factory())
         return scoped_refptr<gfx::GLImage>();
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
-          ->CreateImageForGpuMemoryBuffer(handle,
-                                          size,
-                                          format,
-                                          internalformat,
-                                          client_id_);
+          ->CreateImageForGpuMemoryBuffers(handles, size, formats,
+                                           internalformat, client_id_);
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content