Mac: Require child AllocateGpuMemoryBuffer to not fail

content/child/child_gpu_memory_buffer_manager.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/child/child_gpu_memory_buffer_manager.h"
 
 #include "content/common/child_process_messages.h"
 #include "content/common/generic_shared_memory_id_generator.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 
@@ skipping 27 matching lines @@
                "width",
                size.width(),
                "height",
                size.height());
 
   gfx::GpuMemoryBufferHandle handle;
   IPC::Message* message = new ChildProcessHostMsg_SyncAllocateGpuMemoryBuffer(
       content::GetNextGenericSharedMemoryId(), size.width(), size.height(),
       format, usage, &handle);
   bool success = sender_->Send(message);
-  if (!success || handle.is_null())
-    return nullptr;
+  CHECK(success);
+  CHECK(!handle.is_null());
 
   scoped_ptr<GpuMemoryBufferImpl> buffer(GpuMemoryBufferImpl::CreateFromHandle(
       handle, size, format, usage,
       base::Bind(&DeletedGpuMemoryBuffer, sender_, handle.id)));
-  if (!buffer) {
-    sender_->Send(new ChildProcessHostMsg_DeletedGpuMemoryBuffer(
-        handle.id, gpu::SyncToken()));
-    return nullptr;
-  }
-
+  CHECK(buffer);

[reveman, 2015/12/04 01:47:04]

nit: I don't think this should be able to fail unless there's a bug in our code
and we shouldn't be using CHECKs for that in the general case. If you think this
check is useful for temporarily diagnosing GMB allocation failure then add a
TODO here about removing it later.

fyi, the CHECK(!handle.is_null()) above is different as that can fail as a
result of running out of os resources (e.g. system memory) which is not
something we can fully control and it's best to catch that as early as possible.

[ccameron, 2015/12/04 02:36:20]

I could picture it failing if, for instance, IOSurfaceLookupFromMachPort (from
ChildIOSurfaceManager::AcquireIOSurface, from
GpuMemoryBufferImplIOSurface::CreateFromHandle) requires allocating some sorts
of resources. I think that failure at creation time is more likely, but I'm
still curious if this will be hit.

   return buffer.Pass();
 }
 
 scoped_ptr<gfx::GpuMemoryBuffer>
 ChildGpuMemoryBufferManager::CreateGpuMemoryBufferFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format) {
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 gfx::GpuMemoryBuffer*
 ChildGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
   return GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void ChildGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {
   static_cast<GpuMemoryBufferImpl*>(buffer)
       ->set_destruction_sync_token(sync_token);
 }
 
 }  // namespace content