Change CHROMIUM_image declarations to support multi planar input.

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 682 matching lines @@
 
 void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32 id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
-int32 InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
+int32 InProcessCommandBuffer::CreateImage(const ClientBuffer* const buffers,
                                           size_t width,
                                           size_t height,
                                           unsigned internalformat) {
   CheckSequencedThread();
 
   DCHECK(gpu_memory_buffer_manager_);
+  // TODO(emircan): See http://crbug.com/439520; support passing multiple
+  // buffers when new multi-planar formats are added.
   gfx::GpuMemoryBuffer* gpu_memory_buffer =
-      gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffer);
+      gpu_memory_buffer_manager_->GpuMemoryBufferFromClientBuffer(buffers[0]);
   DCHECK(gpu_memory_buffer);
 
   int32 new_id = next_image_id_.GetNext();
 
   DCHECK(gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
 
   // This handle is owned by the GPU thread and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // queuing of the CreateImage task below.
@@ skipping 78 matching lines @@
 
   DCHECK(gpu_memory_buffer_manager_);
   scoped_ptr<gfx::GpuMemoryBuffer> buffer(
       gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
           gfx::Size(width, height),
           gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat),
           gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
   if (!buffer)
     return -1;
 
-  return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
+  const ClientBuffer& client_buffer = buffer->AsClientBuffer();
+  return CreateImage(const_cast<ClientBuffer* const>(&client_buffer), width,
+                     height, internalformat);
 }
 
 uint32 InProcessCommandBuffer::InsertSyncPoint() {
   uint32 sync_point = g_sync_point_manager.Get().GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
@@ skipping 140 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu