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(crbug.com/678782): Where necessary and possible, disable the

[Primiano Tucci (use gerrit), 2017/01/06 10:58:36]

I don't think this is needed. If you look in the body of this test, I did
already add a narrower exclusion below only on the 512M part. According to
crbug.com/675255#c9:

"In all of these, PartitionAllocTest.GenericAllocGetSize and
PartitionAllocTest.GenericAllocSizes are passing now (whereas they were failing
100% before), so these I would say are fixed (Woo! Thanks!)."

So I'd partially revert this hunk to avoid losing unnecessary coverage.

[danakj, 2017/01/06 15:20:10]

Maybe we can move the TODO down there then

+  // platform's OOM-killing behavior. OOM-killing makes this test flaky on
+  // low-memory devices.
+  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(crbug.com/678782): Where necessary and possible, disable the
+  // platform's OOM-killing behavior. OOM-killing makes this test flaky on
+  // low-memory devices.
+  if (!IsLargeMemoryDevice())

[Primiano Tucci (use gerrit), 2017/01/06 10:58:36]

ditto, I added a narrower exclusion below on the part that triggers OOM

+    return;
+
   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(crbug.com/678782): Where necessary and possible, disable the
+  // platform's OOM-killing behavior. OOM-killing makes this test flaky on
+  // low-memory devices.
+  if (!IsLargeMemoryDevice())
+    return;

[Primiano Tucci (use gerrit), 2017/01/06 10:58:36]

Maybe add a LOG(WARNING) << "Skipping this test on this device because of
crbug.com/678782) so by looking at the buildbot logs one doesn't get the false
feeling that this is just working

+
   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)