Disable certain malloc-library tests for OSX 10.9 32-bit.

base/process/memory_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include "base/process/memory.h"
 
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #if defined(OS_POSIX)
 #include <errno.h>
 #endif
 #if defined(OS_MACOSX)
 #include <malloc/malloc.h>
+#include "base/mac/mac_util.h"
 #include "base/process/memory_unittest_mac.h"
 #endif
 #if defined(OS_LINUX)
 #include <malloc.h>
 #endif
 
 #if defined(OS_WIN)
 // HeapQueryInformation function pointer.
 typedef BOOL (WINAPI* HeapQueryFn)  \
     (HANDLE, HEAP_INFORMATION_CLASS, PVOID, SIZE_T, PSIZE_T);
@@ skipping 67 matching lines @@
 
 // For the following Mac tests:
 // Note that base::EnableTerminationOnHeapCorruption() is called as part of
 // test suite setup and does not need to be done again, else mach_override
 // will fail.
 
 #if !defined(ADDRESS_SANITIZER)
 // The following code tests the system implementation of malloc() thus no need
 // to test it under AddressSanitizer.
 TEST(ProcessMemoryTest, MacMallocFailureDoesNotTerminate) {
+#if ARCH_CPU_32_BITS
+  // The Mavericks malloc library changed in a way which breaks the tricks used
+  // to implement EnableTerminationOnOutOfMemory() with UncheckedMalloc() under
+  // 32-bit.  Under 64-bit the oom_killer code handles this.
+  if (base::mac::IsOSMavericksOrLater())
+    return;
+#endif
+
   // Test that ENOMEM doesn't crash via CrMallocErrorBreak two ways: the exit
   // code and lack of the error string. The number of bytes is one less than
   // MALLOC_ABSOLUTE_MAX_SIZE, more than which the system early-returns NULL and
   // does not call through malloc_error_break(). See the comment at
   // EnableTerminationOnOutOfMemory() for more information.
   void* buf = NULL;
   ASSERT_EXIT(
       {
         base::EnableTerminationOnOutOfMemory();
 
@@ skipping 269 matching lines @@
     base::EnableTerminationOnOutOfMemory();
   }
 };
 
 // TODO(b.kelemen): make UncheckedMalloc and UncheckedCalloc work
 // on Windows as well.
 // UncheckedMalloc() and UncheckedCalloc() work as regular malloc()/calloc()
 // under sanitizer tools.
 #if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 TEST_F(OutOfMemoryHandledTest, UncheckedMalloc) {
+#if defined(OS_MACOSX) && ARCH_CPU_32_BITS
+  // The Mavericks malloc library changed in a way which breaks the tricks used
+  // to implement EnableTerminationOnOutOfMemory() with UncheckedMalloc() under
+  // 32-bit.  The 64-bit malloc library works as desired without tricks.
+  if (base::mac::IsOSMavericksOrLater())
+    return;
+#endif
   EXPECT_TRUE(base::UncheckedMalloc(kSafeMallocSize, &value_));
   EXPECT_TRUE(value_ != NULL);
   free(value_);
 
   EXPECT_FALSE(base::UncheckedMalloc(test_size_, &value_));
   EXPECT_TRUE(value_ == NULL);
 }
 
 TEST_F(OutOfMemoryHandledTest, UncheckedCalloc) {
+#if defined(OS_MACOSX) && ARCH_CPU_32_BITS
+  // The Mavericks malloc library changed in a way which breaks the tricks used
+  // to implement EnableTerminationOnOutOfMemory() with UncheckedCalloc() under
+  // 32-bit.  The 64-bit malloc library works as desired without tricks.
+  if (base::mac::IsOSMavericksOrLater())
+    return;
+#endif
   EXPECT_TRUE(base::UncheckedCalloc(1, kSafeMallocSize, &value_));
   EXPECT_TRUE(value_ != NULL);
   const char* bytes = static_cast<const char*>(value_);
   for (size_t i = 0; i < kSafeMallocSize; ++i)
     EXPECT_EQ(0, bytes[i]);
   free(value_);
 
   EXPECT_TRUE(
       base::UncheckedCalloc(kSafeCallocItems, kSafeCallocSize, &value_));
   EXPECT_TRUE(value_ != NULL);
   bytes = static_cast<const char*>(value_);
   for (size_t i = 0; i < (kSafeCallocItems * kSafeCallocSize); ++i)
     EXPECT_EQ(0, bytes[i]);
   free(value_);
 
   EXPECT_FALSE(base::UncheckedCalloc(1, test_size_, &value_));
   EXPECT_TRUE(value_ == NULL);
 }
 #endif  // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #endif  // !defined(OS_ANDROID) && !defined(OS_OPENBSD) && !defined(OS_WIN)