Add DiscardableMemoryAllocator to work around FD limit issue.

base/memory/discardable_memory_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/memory/discardable_memory.h"
+
+#include <limits>
+
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 const size_t kSize = 1024;
 
+TEST(DiscardableMemoryTest, TooLargeAllocationFails) {

[Philippe, 2013/12/10 13:59:15]

FYI, I'm reverting the CL. ASAN complains due to malloc() returning NULL on
Linux with the provider. I think we should just disable the test with ASAN or
tell ASAN somehow that the NULL is expected. I will reland with the fix.  

+  const size_t kPageSize = 4096;
+  const size_t max_allowed_allocation_size =
+      std::numeric_limits<size_t>::max() - kPageSize + 1;
+  scoped_ptr<DiscardableMemory> memory(
+      DiscardableMemory::CreateLockedMemory(max_allowed_allocation_size + 1));
+  // On certain platforms (e.g. Android), page-alignment would have caused an
+  // overflow resulting in a small allocation if the input size wasn't checked
+  // correctly.
+  ASSERT_FALSE(memory);
+}
+
 TEST(DiscardableMemoryTest, SupportedNatively) {
 #if defined(DISCARDABLE_MEMORY_ALWAYS_SUPPORTED_NATIVELY)
   ASSERT_TRUE(DiscardableMemory::SupportedNatively());
 #else
   // If we ever have a platform that decides at runtime if it can support
   // discardable memory natively, then we'll have to add a 'never supported
   // natively' define for this case. At present, if it's not always supported
   // natively, it's never supported.
   ASSERT_FALSE(DiscardableMemory::SupportedNatively());
 #endif
@@ skipping 45 matching lines @@
   const scoped_ptr<DiscardableMemory> memory(
       DiscardableMemory::CreateLockedMemory(kSize));
   ASSERT_TRUE(memory);
   memory->Unlock();
   ASSERT_DEATH_IF_SUPPORTED(
       { *static_cast<int*>(memory->Memory()) = 0xdeadbeef; }, ".*");
 }
 #endif
 
 }