Add gfx::GpuMemoryBuffer::YUV_420 and GpuMemoryBufferImplSharedMemory support

content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc

Index: content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
index 3d3aee965a3d5aaa526538d9b1aff7d6923e1d24..91552055b963e99ba61b4bdf59393ad18a8e14f0 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
+++ b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
@@ -36,18 +36,12 @@ scoped_ptr<GpuMemoryBufferImpl> GpuMemoryBufferImplSharedMemory::Create(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     Format format) {
-  scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
-
-  size_t stride_in_bytes = 0;
-  if (!StrideInBytes(size.width(), format, &stride_in_bytes))
+  size_t buffer_size = 0u;
+  if (!BufferSizeInBytes(size, format, &buffer_size))
     return scoped_ptr<GpuMemoryBufferImpl>();
 
-  base::CheckedNumeric<size_t> size_in_bytes = stride_in_bytes;
-  size_in_bytes *= size.height();
-  if (!size_in_bytes.IsValid())
-    return scoped_ptr<GpuMemoryBufferImpl>();
-
-  if (!shared_memory->CreateAndMapAnonymous(size_in_bytes.ValueOrDie()))
+  scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
+  if (!shared_memory->CreateAndMapAnonymous(buffer_size))
     return scoped_ptr<GpuMemoryBufferImpl>();
 
   return make_scoped_ptr(new GpuMemoryBufferImplSharedMemory(
@@ -61,17 +55,12 @@ GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
     const gfx::Size& size,
     Format format,
     base::ProcessHandle child_process) {
-  size_t stride_in_bytes = 0;
-  if (!StrideInBytes(size.width(), format, &stride_in_bytes))
-    return gfx::GpuMemoryBufferHandle();
-
-  base::CheckedNumeric<int> buffer_size = stride_in_bytes;
-  buffer_size *= size.height();
-  if (!buffer_size.IsValid())
+  size_t buffer_size = 0u;
+  if (!BufferSizeInBytes(size, format, &buffer_size))
     return gfx::GpuMemoryBufferHandle();
 
   base::SharedMemory shared_memory;
-  if (!shared_memory.CreateAnonymous(buffer_size.ValueOrDie()))
+  if (!shared_memory.CreateAnonymous(buffer_size))
     return gfx::GpuMemoryBufferHandle();
 
   gfx::GpuMemoryBufferHandle handle;
@@ -82,6 +71,27 @@ GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
 }
 
 // static
+bool GpuMemoryBufferImplSharedMemory::BufferSizeInBytes(const gfx::Size& size,
+                                                        Format format,
+                                                        size_t* size_in_bytes) {
+  base::CheckedNumeric<size_t> checked_size_in_bytes = 0u;
+  for (size_t i = 0; i < NumberOfPlanesForGpuMemoryBufferFormat(format); ++i) {

[piman, 2015/04/08 04:58:05]

nit: hoist the the number of planes out of the loop, to avoid the switch on each
iteration.

+    size_t stride_in_bytes = 0;
+    if (!StrideInBytes(size.width(), format, i, &stride_in_bytes))
+      return false;
+    base::CheckedNumeric<size_t> checked_plane_size_in_bytes = stride_in_bytes;
+    checked_plane_size_in_bytes *= size.height() / SubsamplingFactor(format, i);
+    if (!checked_plane_size_in_bytes.IsValid())
+      return false;
+    checked_size_in_bytes += checked_plane_size_in_bytes.ValueOrDie();
+    if (!checked_size_in_bytes.IsValid())
+      return false;
+  }
+  *size_in_bytes = checked_size_in_bytes.ValueOrDie();
+  return true;
+}
+
+// static
 scoped_ptr<GpuMemoryBufferImpl>
 GpuMemoryBufferImplSharedMemory::CreateFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
@@ -91,18 +101,13 @@ GpuMemoryBufferImplSharedMemory::CreateFromHandle(
   if (!base::SharedMemory::IsHandleValid(handle.handle))
     return scoped_ptr<GpuMemoryBufferImpl>();
 
-  size_t stride_in_bytes = 0;
-  if (!StrideInBytes(size.width(), format, &stride_in_bytes))
-    return scoped_ptr<GpuMemoryBufferImpl>();
-
-  base::CheckedNumeric<size_t> size_in_bytes = stride_in_bytes;
-  size_in_bytes *= size.height();
-  if (!size_in_bytes.IsValid())
+  size_t buffer_size = 0u;
+  if (!BufferSizeInBytes(size, format, &buffer_size))
     return scoped_ptr<GpuMemoryBufferImpl>();
 
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(handle.handle, false));
-  if (!shared_memory->Map(size_in_bytes.ValueOrDie()))
+  if (!shared_memory->Map(buffer_size))
     return scoped_ptr<GpuMemoryBufferImpl>();
 
   return make_scoped_ptr<GpuMemoryBufferImpl>(
@@ -124,6 +129,7 @@ bool GpuMemoryBufferImplSharedMemory::IsFormatSupported(Format format) {
     case ETC1:
     case RGBA_8888:
     case BGRA_8888:
+    case YUV_420:
       return true;
     case RGBX_8888:
       return false;
@@ -150,6 +156,15 @@ bool GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(
     case BGRA_8888:
     case RGBX_8888:
       return true;
+    case YUV_420: {
+      for (size_t i = 0; i < NumberOfPlanesForGpuMemoryBufferFormat(format);
+           ++i) {
+        size_t factor = SubsamplingFactor(format, i);
+        if (size.width() % factor || size.height() % factor)
+          return false;
+      }
+      return true;
+    }
   }
 
   NOTREACHED();
@@ -158,8 +173,19 @@ bool GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(
 
 bool GpuMemoryBufferImplSharedMemory::Map(void** data) {
   DCHECK(!mapped_);
+  data[0] = shared_memory_->memory();
+  // Map the other planes if they exist.
+  for (size_t i = 0; i < NumberOfPlanesForGpuMemoryBufferFormat(format_) - 1;

[piman, 2015/04/08 04:58:05]

nit: same here.

+       ++i) {
+    size_t stride_in_bytes = 0;
+    bool valid_stride =
+        StrideInBytes(size_.width(), format_, i, &stride_in_bytes);
+    DCHECK(valid_stride);
+    data[i + 1] =
+        reinterpret_cast<uint8*>(data[i]) +
+        stride_in_bytes * (size_.height() / SubsamplingFactor(format_, i));
+  }
   mapped_ = true;
-  *data = shared_memory_->memory();
   return true;
 }
 
@@ -169,10 +195,13 @@ void GpuMemoryBufferImplSharedMemory::Unmap() {
 }
 
 void GpuMemoryBufferImplSharedMemory::GetStride(uint32* stride) const {
-  size_t stride_in_bytes = 0;
-  bool valid_stride = StrideInBytes(size_.width(), format_, &stride_in_bytes);
-  DCHECK(valid_stride);
-  *stride = stride_in_bytes;
+  for (size_t i = 0; i < NumberOfPlanesForGpuMemoryBufferFormat(format_); ++i) {

[piman, 2015/04/08 04:58:05]

nit: same here.

+    size_t stride_in_bytes = 0;
+    bool valid_stride =
+        StrideInBytes(size_.width(), format_, i, &stride_in_bytes);
+    DCHECK(valid_stride);
+    stride[i] = stride_in_bytes;
+  }
 }
 
 gfx::GpuMemoryBufferHandle GpuMemoryBufferImplSharedMemory::GetHandle() const {