Change CHROMIUM_image declarations to support multi planar input.

content/browser/compositor/buffer_queue.cc

 // Copyright 2014 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 "content/browser/compositor/buffer_queue.h"
 
+#include "base/memory/scoped_vector.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/gfx/gpu_memory_buffer.h"
@@ skipping 143 matching lines @@
 
   unsigned int texture = 0;
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->GenTextures(1, &texture);
   if (!texture)
     return AllocatedSurface();
 
   // We don't want to allow anything more than triple buffering.
   DCHECK_LT(allocated_count_, 4U);
 
-  scoped_ptr<gfx::GpuMemoryBuffer> buffer(
-      gpu_memory_buffer_manager_->AllocateGpuMemoryBufferForScanout(
-          size_, gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(
-                     internalformat_),
-          surface_id_));
-  if (!buffer) {
-    gl->DeleteTextures(1, &texture);
-    DLOG(ERROR) << "Failed to allocate GPU memory buffer";
-    return AllocatedSurface();
+  std::vector<gfx::GpuMemoryBuffer::Format> gpu_memory_buffer_formats;
+  gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormats(
+      internalformat_, &gpu_memory_buffer_formats);
+  int num_buffers = gpu_memory_buffer_formats.size();
+
+  DCHECK_GE(num_buffers, 1);

[reveman, 2015/03/04 05:56:00]

I think it's correct to assume that the number of buffers are one in this case.
As we can assume that, why deal with all these vectors here? The old code with
just one buffer should be sufficient.

[emircan, 2015/03/04 23:31:50]

I agree that it is 1 currently. But if we were to support
CreateGpuMemoryBufferImageCHROMIUM with GL_RGB_YUV420 wouldn't we need to back
it with multiple buffers?

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

I read the DCHECK wrong in my initial comment. I think this should be
DCHECK_EQ(num_buffers, 1) as I don't think it makes for this specific code to
ever support multi-plane buffers. The buffer queue is explicitly for single
plane RGB buffers.

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

Done. Reverted to original single buffer usage.

+
+  ScopedVector<gfx::GpuMemoryBuffer> buffers;
+  ClientBuffer client_buffers[num_buffers];
+  for (int i = 0; i < num_buffers; ++i) {
+    buffers.push_back(
+        gpu_memory_buffer_manager_->AllocateGpuMemoryBufferForScanout(
+            size_, gpu_memory_buffer_formats[i],
+            surface_id_));
+
+    if (!buffers[i]) {
+      gl->DeleteTextures(1, &texture);
+      DLOG(ERROR) << "Failed to allocate GPU memory buffer";
+      return AllocatedSurface();
+    }
+
+    client_buffers[i] = buffers[i]->AsClientBuffer();
   }
 
-  unsigned int id = gl->CreateImageCHROMIUM(
-      buffer->AsClientBuffer(), size_.width(), size_.height(), internalformat_);
+  unsigned int id = gl->CreateImageCHROMIUM(client_buffers, size_.width(),
+                                            size_.height(), internalformat_);
 
   if (!id) {
     LOG(ERROR) << "Failed to allocate backing image surface";
     gl->DeleteTextures(1, &texture);
     return AllocatedSurface();
   }
   allocated_count_++;
   gl->BindTexture(GL_TEXTURE_2D, texture);
   gl->BindTexImage2DCHROMIUM(GL_TEXTURE_2D, id);
   return AllocatedSurface(texture, id, gfx::Rect(size_));
 }
 
 }  // namespace content