Add base::TerminateBecauseOutOfMemory

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 "base/debug/alias.h"
+#include "base/process/memory.h"
 #include "base/process/process_metrics.h"
 #include "content/child/child_thread_impl.h"
 #include "content/common/child_process_messages.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 namespace {
 
 class ChildSharedBitmap : public SharedMemoryBitmap {
@@ skipping 15 matching lines @@
 
   ~ChildSharedBitmap() override {
     sender_->Send(new ChildProcessHostMsg_DeletedSharedBitmap(id()));
   }
 
  private:
   scoped_refptr<ThreadSafeSender> sender_;
   scoped_ptr<base::SharedMemory> shared_memory_holder_;
 };
 
-#if defined(OS_WIN)
-
 // Collect extra information for debugging bitmap creation failures.
 void CollectMemoryUsageAndDie(const gfx::Size& size) {
+#if defined(OS_WIN)
   int width = size.width();
   int height = size.height();
   DWORD last_error = GetLastError();
 
   scoped_ptr<base::ProcessMetrics> metrics(
       base::ProcessMetrics::CreateProcessMetrics(
           base::GetCurrentProcessHandle()));
 
   size_t private_bytes = 0;
   size_t shared_bytes = 0;
   metrics->GetMemoryBytes(&private_bytes, &shared_bytes);
 
   base::debug::Alias(&width);
   base::debug::Alias(&height);
   base::debug::Alias(&last_error);
   base::debug::Alias(&private_bytes);
   base::debug::Alias(&shared_bytes);
-
-  CHECK(false);
+#endif
+  base::CrashWithOutOfMemory();
 }
 
-#endif
-
 }  // namespace
 
 SharedMemoryBitmap::SharedMemoryBitmap(uint8* pixels,
                                        const cc::SharedBitmapId& id,
                                        base::SharedMemory* shared_memory)
     : SharedBitmap(pixels, id), shared_memory_(shared_memory) {
 }
 
 ChildSharedBitmapManager::ChildSharedBitmapManager(
     scoped_refptr<ThreadSafeSender> sender)
@@ skipping 22 matching lines @@
   if (!cc::SharedBitmap::SizeInBytes(size, &memory_size))
     return scoped_ptr<SharedMemoryBitmap>();
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
   scoped_ptr<base::SharedMemory> memory;
 #if defined(OS_POSIX)
   base::SharedMemoryHandle handle;
   sender_->Send(new ChildProcessHostMsg_SyncAllocateSharedBitmap(
       memory_size, id, &handle));
   memory = make_scoped_ptr(new base::SharedMemory(handle, false));
   if (!memory->Map(memory_size))
-    CHECK(false);
+    CollectMemoryUsageAndDie(size);
 #else
   memory = ChildThreadImpl::AllocateSharedMemory(memory_size, sender_.get());
-#if defined(OS_WIN)
   if (!memory)
     CollectMemoryUsageAndDie(size);
-#endif
 
-  CHECK(memory);
-  if (!memory->Map(memory_size)) {
-#if defined(OS_WIN)
+  if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size);
-#endif
-    CHECK(false);
-  }
+
   base::SharedMemoryHandle handle_to_send = memory->handle();
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       memory_size, handle_to_send, id));
 #endif
   return make_scoped_ptr(new ChildSharedBitmap(sender_, memory.Pass(), id));
 }
 
 scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::GetSharedBitmapFromId(
     const gfx::Size&,
     const cc::SharedBitmapId&) {
   NOTREACHED();
   return scoped_ptr<cc::SharedBitmap>();
 }
 
 scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::GetBitmapForSharedMemory(
     base::SharedMemory* mem) {
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
   base::SharedMemoryHandle handle_to_send = mem->handle();
 #if defined(OS_POSIX)
   if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
     return scoped_ptr<cc::SharedBitmap>();
 #endif
   sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
       mem->mapped_size(), handle_to_send, id));
 
   return make_scoped_ptr(new ChildSharedBitmap(sender_, mem, id));
 }
 
 }  // namespace content