Don't run memory-intensive tests on low-memory devices.

base/allocator/partition_allocator/partition_alloc_unittest.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 "base/allocator/partition_allocator/partition_alloc.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 593 matching lines @@
   newCharPtr = static_cast<char*>(newPtr);
   EXPECT_EQ(*newCharPtr, 'F');
 
   partitionFreeGeneric(genericAllocator.root(), newPtr);
   TestShutdown();
 }
 
 // Test the generic allocation functions can handle some specific sizes of
 // interest.
 TEST(PartitionAllocTest, GenericAllocSizes) {
+  // TODO: Where necessary and possible, disable the platform's OOM-killing

[danakj, 2017/01/05 23:00:44]

TODO, unlike the old FIXME, always comes with a name or bug link. ie the syntax
is "TODO(crbug.com/678782): "

[palmer, 2017/01/06 00:30:53]

Done.

+  // behavior. OOM-killing makes this test flaky on low-memory devices.
+  // crbug.com/678782
+  if (!IsLargeMemoryDevice())
+    return;
+
   TestSetup();
 
   void* ptr = partitionAllocGeneric(genericAllocator.root(), 0, typeName);
   EXPECT_TRUE(ptr);
   partitionFreeGeneric(genericAllocator.root(), ptr);
 
   // kPartitionPageSize is interesting because it results in just one
   // allocation per page, which tripped up some corner cases.
   size_t size = kPartitionPageSize - kExtraAllocSize;
   ptr = partitionAllocGeneric(genericAllocator.root(), size, typeName);
@@ skipping 77 matching lines @@
   // Do we correctly get a null for a failed allocation?
   EXPECT_EQ(0, partitionAllocGenericFlags(genericAllocator.root(),
                                           PartitionAllocReturnNull,
                                           3u * 1024 * 1024 * 1024, typeName));
 
   TestShutdown();
 }
 
 // Test that we can fetch the real allocated size after an allocation.
 TEST(PartitionAllocTest, GenericAllocGetSize) {
+  // TODO: Where necessary and possible, disable the platform's OOM-killing
+  // behavior. OOM-killing makes this test flaky on low-memory devices.

[danakj, 2017/01/05 23:00:44]

If it's flaky shouldn't it be disabled, or is the comment wrong here.

[palmer, 2017/01/06 00:30:53]

Oops, forgot to put the actual code in. Sigh.

+  // crbug.com/678782
+
   TestSetup();
 
   void* ptr;
   size_t requestedSize, actualSize, predictedSize;
 
   EXPECT_TRUE(partitionAllocSupportsGetSize());
 
   // Allocate something small.
   requestedSize = 511 - kExtraAllocSize;
   predictedSize =
@@ skipping 538 matching lines @@
   EXPECT_TRUE(bucket->activePagesHead);
   EXPECT_TRUE(bucket->emptyPagesHead);
   EXPECT_TRUE(bucket->decommittedPagesHead);
 
   TestShutdown();
 }
 
 #if !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 
 static void DoReturnNullTest(size_t allocSize) {
+  // TODO: Where necessary and possible, disable the platform's OOM-killing
+  // behavior. OOM-killing makes this test flaky on low-memory devices.
+  // crbug.com/678782
+  if (!IsLargeMemoryDevice())
+    return;
+
   TestSetup();
 
   EXPECT_TRUE(SetAddressSpaceLimit());
 
   // Work out the number of allocations for 6 GB of memory.
   const int numAllocations = (6 * 1024 * 1024) / (allocSize / 1024);
 
   void** ptrs = reinterpret_cast<void**>(partitionAllocGeneric(
       genericAllocator.root(), numAllocations * sizeof(void*), typeName));
   int i;
@@ skipping 834 matching lines @@
     partitionFreeGeneric(genericAllocator.root(), ptr1);
     partitionFreeGeneric(genericAllocator.root(), ptr2);
   }
 
   TestShutdown();
 }
 
 }  // namespace base
 
 #endif  // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)