android: Enable death on malloc/operator new failure.

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 <stddef.h>
 
@@ skipping 64 matching lines @@
   ADD_FAILURE() << "This test is not supported in this build configuration.";
 #endif
 }
 
 #endif  // defined(OS_MACOSX)
 
 TEST(MemoryTest, AllocatorShimWorking) {
   ASSERT_TRUE(base::allocator::IsAllocatorInitialized());
 }
 
-// Android doesn't implement set_new_handler, so we can't use the
-// OutOfMemoryTest cases. OpenBSD does not support these tests either.
-// Don't test these on ASan/TSan/MSan configurations: only test the real
-// allocator.
+// OpenBSD does not support these tests. Don't test these on ASan/TSan/MSan
+// configurations: only test the real allocator.
 // Windows only supports these tests with the allocator shim in place.
-#if !defined(OS_ANDROID) && !defined(OS_OPENBSD) && \
-    BUILDFLAG(ENABLE_WIN_ALLOCATOR_SHIM_TESTS) &&   \
+#if !defined(OS_OPENBSD) && \
+    BUILDFLAG(ENABLE_WIN_ALLOCATOR_SHIM_TESTS) && \
     !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 
 namespace {
 #if defined(OS_WIN)
 // Windows raises an exception rather than using LOG(FATAL) in order to make the
 // exit code unique to OOM.
 const char* kOomRegex = "";
 const int kExitCode = base::win::kOomExceptionCode;
 #else
 const char* kOomRegex = "Out of memory";
@@ skipping 80 matching lines @@
 TEST_F(OutOfMemoryDeathTest, AlignedRealloc) {
   ASSERT_EXIT({
       SetUpInDeathAssert();
       value_ = _aligned_realloc(NULL, test_size_, 8);
     }, testing::ExitedWithCode(kExitCode), kOomRegex);
 }
 #endif  // defined(OS_WIN)
 
 // OS X has no 2Gb allocation limit.
 // See https://crbug.com/169327.
-#if !defined(OS_MACOSX)
+#if !defined(OS_MACOSX) && !defined(OS_ANDROID)

[Nico, 2016/08/03 14:13:20]

Why ifdef out these tests? Maybe update the comment two lines above.

[Primiano Tucci (use gerrit), 2016/08/03 15:04:48]

So the thing is that, as things stands today, Android doesn't have the 2gb check
just because nobody bothered there. This test was passing just because the
virtual address space is so fragmented by the zygote that is practically
impossible to mmap/malloc(2GB). 
Having said that, we should probably fix the glitch and move that code from
win-only to the shim, but that is something that I don't want to do here because
would be new for Android and I have no idea if will just work(TM)

[Nico, 2016/08/03 15:06:52]

Doesn't this test run on linux as well? Or am I missing an ifdef somewhere? If
it runs on linux, how can it work if the check for this is in a win-only file?

[Primiano Tucci (use gerrit), 2016/08/03 15:21:45]

Yes, it does. See logdog output for this CL in https://goo.gl/3Vc5DP
This is not a win-only file (that WIN in the name of
ENABLE_WIN_ALLOCATOR_SHIM_TESTS is misleading)

On Linux desktop this is working because tcmalloc has baked in the 2GB limit
check.
See  IsAllocSizePermitted in tcmalloc.cc
(https://cs.chromium.org/chromium/src/third_party/tcmalloc/chromium/src/tcmall...)

On Android we don't use tcmalloc, so we have no protection (just "accidental"
one due to fragmentation on 32 bit)

 TEST_F(OutOfMemoryDeathTest, SecurityNew) {
   ASSERT_EXIT({
       SetUpInDeathAssert();
       value_ = operator new(insecure_test_size_);
     }, testing::ExitedWithCode(kExitCode), kOomRegex);
 }
 
 TEST_F(OutOfMemoryDeathTest, SecurityNewArray) {
   ASSERT_EXIT({
       SetUpInDeathAssert();
@@ skipping 31 matching lines @@
 
 // POSIX does not define an aligned realloc function.
 #if defined(OS_WIN)
 TEST_F(OutOfMemoryDeathTest, SecurityAlignedRealloc) {
   ASSERT_EXIT({
       SetUpInDeathAssert();
       value_ = _aligned_realloc(NULL, insecure_test_size_, 8);
     }, testing::ExitedWithCode(kExitCode), kOomRegex);
 }
 #endif  // defined(OS_WIN)
-#endif  // !defined(OS_MACOSX)
+#endif  // !defined(OS_MACOSX) && !defined(OS_ANDROID)
 
 #if defined(OS_LINUX)
 
 TEST_F(OutOfMemoryDeathTest, Valloc) {
   ASSERT_DEATH({
       SetUpInDeathAssert();
       value_ = valloc(test_size_);
     }, kOomRegex);
 }
 
@@ skipping 151 matching lines @@
 
     // We enable termination on OOM - just as Chrome does at early
     // initialization - and test that UncheckedMalloc and  UncheckedCalloc
     // properly by-pass this in order to allow the caller to handle OOM.
     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) {
   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) {
   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) &&
-        // !defined(ALLOCATOR_SHIM)) && !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
+#endif  // !defined(OS_OPENBSD) && BUILDFLAG(ENABLE_WIN_ALLOCATOR_SHIM_TESTS) &&
+        // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)