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 810 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,
+    const std::vector<gfx::GpuMemoryBufferHandle>& handles,
     const gfx::Size& size,
-    gfx::GpuMemoryBuffer::Format format,
+    const std::vector<gfx::GpuMemoryBuffer::Format>& formats,
     uint32 internalformat) {
+  // TODO(emircan): See http://crbug.com/439520; support passing multiple

[reveman, 2015/03/05 19:35:32]

Sorry if I didn't make this clear but I don't want any of these TODOs. I'd like
to see all the plumbing for multi-plane image support before I am convinced that
it is a good idea.

[emircan, 2015/03/09 21:07:22]

Ok, going all the way :) I got some advice to keep CL small so I was hesitant,
but I totally understand that you want to see the whole picture. I have some
questions regarding the next steps as well.

+  // buffers when new multi-planar formats are added.
+  if ((handles.size() != 1) || (formats.size() != 1)) {
+    NOTIMPLEMENTED();
+    return scoped_refptr<gfx::GLImage>();
+  }
+
+  const gfx::GpuMemoryBufferHandle& handle = handles[0];
+  const gfx::GpuMemoryBuffer::Format& format = formats[0];
+
   switch (handle.type) {
     case gfx::SHARED_MEMORY_BUFFER: {
       scoped_refptr<gfx::GLImageSharedMemory> image(
           new gfx::GLImageSharedMemory(size, internalformat));
       if (!image->Initialize(handle, format))
         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,
+          ->CreateImageForGpuMemoryBuffer(handles,
                                           size,
-                                          format,
+                                          formats,
                                           internalformat,
                                           client_id_);
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content