Die on an OOM situation in many more cases....

base/process_util_unittest.cc

 // Copyright (c) 2009 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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
@@ skipping 11 matching lines @@
 #include <glib.h>
 #endif
 #if defined(OS_POSIX)
 #include <fcntl.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
 #endif
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
+#if defined(OS_MACOSX)
+#include "base/process_util_unittest_mac.h"
+#endif
 
 namespace base {
 
 class ProcessUtilTest : public MultiProcessTest {
 #if defined(OS_POSIX)
  public:
   // Spawn a child process that counts how many file descriptors are open.
   int CountOpenFDsInChild();
 #endif
 };
@@ skipping 457 matching lines @@
       "0 0 0 0 "  // <- No CPU, apparently.
       "16 0 1 0 1676099790 2957312 114 4294967295 134512640 134528148 "
       "3221224832 3221224344 3086339742 0 0 0 0 0 0 0 17 0 0 0";
 
   EXPECT_EQ(0, ParseProcStatCPU(kSelfStat));
 }
 #endif
 
 #endif  // defined(OS_POSIX)
 
-// TODO(vandebo) make this work on Windows and Mac too.
-#if defined(OS_LINUX)
+// TODO(vandebo) make this work on Windows too.
+#if !defined(OS_WIN)
 
 #if defined(USE_TCMALLOC)
 extern "C" {
 int tc_set_new_mode(int mode);
 }
 #endif  // defined(USE_TCMALLOC)
 
 class OutOfMemoryTest : public testing::Test {
  public:
   OutOfMemoryTest()
       : value_(NULL),
         // Make test size as large as possible minus a few pages so
         // that alignment or other rounding doesn't make it wrap.
-        test_size_(std::numeric_limits<std::size_t>::max() - 8192) {
+        test_size_(std::numeric_limits<std::size_t>::max() - 12 * 1024),
+        signed_test_size_(std::numeric_limits<ssize_t>::max()) {
   }
 
   virtual void SetUp() {
     // Must call EnableTerminationOnOutOfMemory() because that is called from
     // chrome's main function and therefore hasn't been called yet.
     EnableTerminationOnOutOfMemory();
 #if defined(USE_TCMALLOC)
     tc_set_new_mode(1);
   }
 
   virtual void TearDown() {
     tc_set_new_mode(0);
 #endif  // defined(USE_TCMALLOC)
   }
 
   void* value_;
   size_t test_size_;
+  ssize_t signed_test_size_;
 };
 
 TEST_F(OutOfMemoryTest, New) {
+  ASSERT_DEATH(value_ = operator new(test_size_), "");
+}
+
+TEST_F(OutOfMemoryTest, NewArray) {
   ASSERT_DEATH(value_ = new char[test_size_], "");
 }
 
 TEST_F(OutOfMemoryTest, Malloc) {
   ASSERT_DEATH(value_ = malloc(test_size_), "");
 }
 
 TEST_F(OutOfMemoryTest, Realloc) {
   ASSERT_DEATH(value_ = realloc(NULL, test_size_), "");
 }
 
 TEST_F(OutOfMemoryTest, Calloc) {
   ASSERT_DEATH(value_ = calloc(1024, test_size_ / 1024L), "");
 }
 
 TEST_F(OutOfMemoryTest, Valloc) {
   ASSERT_DEATH(value_ = valloc(test_size_), "");
 }
 
+#if defined(OS_LINUX)
 TEST_F(OutOfMemoryTest, Pvalloc) {
   ASSERT_DEATH(value_ = pvalloc(test_size_), "");
 }
 
 TEST_F(OutOfMemoryTest, Memalign) {
   ASSERT_DEATH(value_ = memalign(4, test_size_), "");
 }
 
 TEST_F(OutOfMemoryTest, ViaSharedLibraries) {
   // g_try_malloc is documented to return NULL on failure. (g_malloc is the
   // 'safe' default that crashes if allocation fails). However, since we have
   // hopefully overridden malloc, even g_try_malloc should fail. This tests
   // that the run-time symbol resolution is overriding malloc for shared
   // libraries as well as for our code.
   ASSERT_DEATH(value_ = g_try_malloc(test_size_), "");
 }
 
 
 TEST_F(OutOfMemoryTest, Posix_memalign) {
   // Grab the return value of posix_memalign to silence a compiler warning
   // about unused return values. We don't actually care about the return
   // value, since we're asserting death.
   ASSERT_DEATH(EXPECT_EQ(ENOMEM, posix_memalign(&value_, 8, test_size_)), "");
 }
+#endif  // OS_LINUX
 
-#endif  // defined(OS_LINUX)
+#if defined(OS_MACOSX)
+
+// Since these allocation functions take a signed size, it's possible that
+// calling them just once won't be enough to exhaust memory.
+
+TEST_F(OutOfMemoryTest, CFAllocatorSystemDefault) {
+  ASSERT_DEATH(while ((value_ =
+      AllocateViaCFAllocatorSystemDefault(signed_test_size_))) {}, "");
+}
+
+TEST_F(OutOfMemoryTest, CFAllocatorMalloc) {
+  ASSERT_DEATH(while ((value_ =
+      AllocateViaCFAllocatorMalloc(signed_test_size_))) {}, "");
+}
+
+TEST_F(OutOfMemoryTest, CFAllocatorMallocZone) {
+  ASSERT_DEATH(while ((value_ =
+      AllocateViaCFAllocatorMallocZone(signed_test_size_))) {}, "");
+}
+
+TEST_F(OutOfMemoryTest, PsychoticallyBigObjCObject) {
+  ASSERT_DEATH(while ((value_ =
+      AllocatePsychoticallyBigObjCObject())) {}, "");
+}
+
+#endif  // OS_MACOSX
+
+#endif  // !defined(OS_WIN)
 
 }  // namespace base