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 =
+      gpu::ImageFactory::NumberOfPlanesForImageFormat(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>();
+  }
+
+  switch (handle_type) {
     case gfx::SHARED_MEMORY_BUFFER: {
+      if (num_buffers != 1) {
+        DLOG(ERROR)
+            << "SHARED_MEMORY_BUFFER doesn't support multi-plane formats.";
+        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