content: Move type selection logic out of GpuMemoryBufferImpl.

content/common/child_process_host_impl.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 "content/common/child_process_host_impl.h"
 
 #include <limits>
 
 #include "base/atomic_sequence_num.h"
 #include "base/command_line.h"
@@ skipping 302 matching lines @@
   if (delegate_->CanShutdown())
     Send(new ChildProcessMsg_Shutdown());
 }
 
 void ChildProcessHostImpl::OnAllocateGpuMemoryBuffer(
     uint32 width,
     uint32 height,
     gfx::GpuMemoryBuffer::Format format,
     gfx::GpuMemoryBuffer::Usage usage,
     IPC::Message* reply) {
-  base::CheckedNumeric<int> size = width;
-  size *= height;
-  if (!size.IsValid()) {

[piman, 2014/11/11 22:38:30]

Why removing this?

[reveman, 2014/11/12 05:09:20]

This check is now done by
GpuMemoryBufferImplSharedMemory::AllocateForChildProcess. The reasoning is that
only ::AllocateForChildProcess implementations can know what values can cause
problems. In the SharedMemory case, bbp * width * height overflow is what we
need to check for but that could be different for other implementations.

[piman, 2014/11/14 03:59:44]

Ok, can you add a comment? It's generally good to have checks closer to the IPC
handlers, because that's where the security decisions are usually taken. If it's
in other places it's easy to lose the checks during refactoring etc.

[reveman, 2014/11/17 02:26:53]

Done.

+  // TODO(reveman): Add support for other types of GpuMemoryBuffers.
+  if (!GpuMemoryBufferImplSharedMemory::IsFormatSupported(format) ||
+      !GpuMemoryBufferImplSharedMemory::IsUsageSupported(usage)) {
     GpuMemoryBufferAllocated(reply, gfx::GpuMemoryBufferHandle());
     return;
   }
-
-  // TODO(reveman): Add support for other types of GpuMemoryBuffers.
-  if (!GpuMemoryBufferImplSharedMemory::IsConfigurationSupported(
-          gfx::Size(width, height), format, usage)) {
-    GpuMemoryBufferAllocated(reply, gfx::GpuMemoryBufferHandle());
-    return;
-  }
 
   // Note: It is safe to use base::Unretained here as the shared memory
   // implementation of AllocateForChildProcess() calls this synchronously.
   GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
       g_next_gpu_memory_buffer_id.GetNext(),
       gfx::Size(width, height),
       format,
       peer_handle_,
       base::Bind(&ChildProcessHostImpl::GpuMemoryBufferAllocated,
                  base::Unretained(this),
                  reply));
 }
 
 void ChildProcessHostImpl::OnDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     uint32 sync_point) {
   // Note: Nothing to do here as ownership of shared memory backed
   // GpuMemoryBuffers is passed with IPC.
 }
 
 void ChildProcessHostImpl::GpuMemoryBufferAllocated(
     IPC::Message* reply,
     const gfx::GpuMemoryBufferHandle& handle) {
   ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer::WriteReplyParams(reply,
                                                                     handle);
   Send(reply);
 }
 
 }  // namespace content