Change CHROMIUM_image declarations to support multi planar input.

content/common/gpu/gpu_command_buffer_stub.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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 122 matching lines @@
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->renderer_pid());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   res->SetDouble("limit_bytes",
                  channel->gpu_channel_manager()
                      ->gpu_memory_manager()
                      ->GetMaximumClientAllocation());
   return new DevToolsChannelData(res.release());
 }
 
 bool IsSupportedImageFormat(const gpu::Capabilities& capabilities,

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

Hm, this name is confusing with support for multiple buffers per image. I think
this should have been named IsSupportedGpuMemoryBufferFormat. Can you fix that
as part of this patch?

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

Hm, this name is confusing with support for multiple buffers per image. I think
this should have been named IsSupportedGpuMemoryBufferFormat. Can you fix that
as part of this patch?

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

It was removed in the rebase.

                             gfx::GpuMemoryBuffer::Format format) {
   switch (format) {
     case gfx::GpuMemoryBuffer::ATC:
     case gfx::GpuMemoryBuffer::ATCIA:
       return capabilities.texture_format_atc;
     case gfx::GpuMemoryBuffer::BGRA_8888:
       return capabilities.texture_format_bgra8888;
     case gfx::GpuMemoryBuffer::DXT1:
       return capabilities.texture_format_dxt1;
     case gfx::GpuMemoryBuffer::DXT5:
@@ skipping 801 matching lines @@
   if (has_callback) {
     if (!memory_manager_client_state_) {
       memory_manager_client_state_.reset(GetMemoryManager()->CreateClientState(
           this, surface_id_ != 0, true));
     }
   } else {
     memory_manager_client_state_.reset();
   }
 }
 
-void GpuCommandBufferStub::OnCreateImage(int32 id,
-                                         gfx::GpuMemoryBufferHandle handle,
-                                         gfx::Size size,
-                                         gfx::GpuMemoryBuffer::Format format,
-                                         uint32 internalformat) {
+void GpuCommandBufferStub::OnCreateImage(
+    int32 id,
+    std::vector<gfx::GpuMemoryBufferHandle> handles,
+    gfx::Size size,
+    std::vector<gfx::GpuMemoryBuffer::Format> formats,
+    uint32 internalformat) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateImage");
 
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image already exists with same ID.";
     return;
   }
 
-  if (!IsSupportedImageFormat(decoder_->GetCapabilities(), format)) {
-    LOG(ERROR) << "Image format is not supported.";
-    return;
+  int num_buffers = handles.size();
+
+  for (int i = 0; i < num_buffers; ++i) {

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

for (auto format : formats) instead?

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

I could have. But, now
gpu::ImageFactory::IsImageFormatCompatibleWithGpuMemoryBufferFormat() requires
index.

+    if (!IsSupportedImageFormat(decoder_->GetCapabilities(), formats[i])) {

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

You have to be careful here. What if size of formats is less than size of
handles? A malicious renderer could make the GPU process read past the end of a
vector this way.

I think we need to check the number of buffers we expect above based on
internalformat and return early if |formats| or |handles| is not of the correct
size.

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

I see, it is possible to give those input through IPC. I added them as CHECK_EQ
but wouldn't it be a performance penalty?

+      LOG(ERROR) << "Image format is not supported.";
+      return;
+    }
   }
 
   scoped_refptr<gfx::GLImage> image = channel()->CreateImageForGpuMemoryBuffer(
-      handle, size, format, internalformat);
+      handles, size, formats, internalformat);
   if (!image.get())
     return;
 
   image_manager->AddImage(image.get(), id);
 }
 
 void GpuCommandBufferStub::OnDestroyImage(int32 id) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyImage");
 
   if (!decoder_)
@@ skipping 112 matching lines @@
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, latency_info));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content