Exit immediately on failure to allocate SharedMemory.

content/child/child_shared_bitmap_manager.cc

 // Copyright (c) 2013 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_shared_bitmap_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 93 matching lines @@
   size_t memory_size;
   if (!cc::SharedBitmap::SizeInBytes(size, &memory_size))
     return std::unique_ptr<SharedMemoryBitmap>();
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
   std::unique_ptr<base::SharedMemory> memory;
 #if defined(OS_POSIX)
   base::SharedMemoryHandle handle;
   bool send_success =
       sender_->Send(new ChildProcessHostMsg_SyncAllocateSharedBitmap(
           memory_size, id, &handle));
-  if (!send_success)
-    return nullptr;
+  if (!send_success) {
+    // Callers of this method are not prepared to handle failures during
+    // shutdown. Exit immediately. https://crbug.com/615121.
+    exit(EXIT_SUCCESS);

[Avi (use Gerrit), 2016/06/01 21:07:38]

/base/process/memory.h's TerminateBecauseOutOfMemory() ?

[erikchen, 2016/06/01 21:10:46]

That is both inaccurate, as this is not an OOM, and emits a CrashDump, which
distorts our crash figures and causes ReleaseBlock bugs to be assigned to me. 

+  }
   memory = base::WrapUnique(new base::SharedMemory(handle, false));
   if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size, memory_size);
 #else
   bool out_of_memory;
   memory = ChildThreadImpl::AllocateSharedMemory(memory_size, sender_.get(),
                                                  &out_of_memory);
   if (!memory) {
-    if (out_of_memory)
+    if (out_of_memory) {
       CollectMemoryUsageAndDie(size, memory_size);
-    else
-      return nullptr;
+    } else {
+      // Callers of this method are not prepared to handle failures during
+      // shutdown. Exit immediately. https://crbug.com/615121.
+      exit(EXIT_SUCCESS);
+    }
   }
 
   if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size, memory_size);
 
   base::SharedMemoryHandle handle_to_send = memory->handle();
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       memory_size, handle_to_send, id));
 #endif
   return base::WrapUnique(
@@ skipping 15 matching lines @@
   if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
     return std::unique_ptr<cc::SharedBitmap>();
 #endif
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       mem->mapped_size(), handle_to_send, id));
 
   return base::WrapUnique(new ChildSharedBitmap(sender_, mem, id));
 }
 
 }  // namespace content