Align ashmem region sizes to page size after ashmem creation failed.

base/memory/discardable_memory_allocator_android_unittest.cc

 // Copyright 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_allocator_android.h"
 
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/memory/discardable_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 
 const char kAllocatorName[] = "allocator-for-testing";
 
 const size_t kAshmemRegionSizeForTesting = 32 * 1024 * 1024;
 const size_t kPageSize = 4096;
 
+const size_t kMaxAllowedAllocationSize =
+    std::numeric_limits<size_t>::max() - kPageSize + 1;
+
 class DiscardableMemoryAllocatorTest : public testing::Test {
  protected:
   DiscardableMemoryAllocatorTest()
       : allocator_(kAllocatorName, kAshmemRegionSizeForTesting) {
   }
 
   DiscardableMemoryAllocator allocator_;
 };
 
 void WriteToDiscardableMemory(DiscardableMemory* memory, size_t size) {
   // Write to the first and the last pages only to avoid paging in up to 64
   // MBytes.
   static_cast<char*>(memory->Memory())[0] = 'a';
   static_cast<char*>(memory->Memory())[size - 1] = 'a';
 }
 
 TEST_F(DiscardableMemoryAllocatorTest, Basic) {
   const size_t size = 128;
   scoped_ptr<DiscardableMemory> memory(allocator_.Allocate(size));
   ASSERT_TRUE(memory);
   WriteToDiscardableMemory(memory.get(), size);
 }
 
 TEST_F(DiscardableMemoryAllocatorTest, ZeroAllocationIsNotSupported) {
   scoped_ptr<DiscardableMemory> memory(allocator_.Allocate(0));
   ASSERT_FALSE(memory);
 }
 
 TEST_F(DiscardableMemoryAllocatorTest, TooLargeAllocationFails) {
-  const size_t max_allowed_allocation_size =
-      std::numeric_limits<size_t>::max() - kPageSize + 1;
   scoped_ptr<DiscardableMemory> memory(
-      allocator_.Allocate(max_allowed_allocation_size + 1));
+      allocator_.Allocate(kMaxAllowedAllocationSize + 1));
   // Page-alignment would have caused an overflow resulting in a small
   // allocation if the input size wasn't checked correctly.
   ASSERT_FALSE(memory);
 }
 
 TEST_F(DiscardableMemoryAllocatorTest,
        AshmemRegionsAreNotSmallerThanRequestedSize) {
-  const size_t size = std::numeric_limits<size_t>::max() - kPageSize + 1;
   // The creation of the underlying ashmem region is expected to fail since
   // there should not be enough room in the address space. When ashmem creation
   // fails, the allocator repetitively retries by dividing the size by 2. This
   // size should not be smaller than the size the user requested so the
   // allocation here should just fail (and not succeed with the minimum ashmem
   // region size).
-  scoped_ptr<DiscardableMemory> memory(allocator_.Allocate(size));
+  scoped_ptr<DiscardableMemory> memory(
+      allocator_.Allocate(kMaxAllowedAllocationSize));
   ASSERT_FALSE(memory);
 }
 
+TEST_F(DiscardableMemoryAllocatorTest, AshmemRegionsAreAlwaysPageAligned) {
+  // Use a separate allocator here so that we can override the ashmem region
+  // size.
+  DiscardableMemoryAllocator allocator(
+      kAllocatorName, kMaxAllowedAllocationSize);
+  scoped_ptr<DiscardableMemory> memory(allocator.Allocate(kPageSize));
+  ASSERT_TRUE(memory);
+  EXPECT_GT(kMaxAllowedAllocationSize, allocator.last_ashmem_region_size());
+  ASSERT_TRUE(allocator.last_ashmem_region_size() % kPageSize == 0);
+}
+
 TEST_F(DiscardableMemoryAllocatorTest, LargeAllocation) {
   // Note that large allocations should just use DiscardableMemoryAndroidSimple
   // instead.
   const size_t size = 64 * 1024 * 1024;
   scoped_ptr<DiscardableMemory> memory(allocator_.Allocate(size));
   ASSERT_TRUE(memory);
   WriteToDiscardableMemory(memory.get(), size);
 }
 
 TEST_F(DiscardableMemoryAllocatorTest, ChunksArePageAligned) {
@@ skipping 165 matching lines @@
   // The last page of the first ashmem region should be used for this
   // allocation.
   scoped_ptr<DiscardableMemory> memory3(allocator_.Allocate(kPageSize));
   ASSERT_TRUE(memory3);
   WriteToDiscardableMemory(memory3.get(), kPageSize);
   EXPECT_EQ(memory3->Memory(), static_cast<char*>(memory1->Memory()) + size);
 }
 
 }  // namespace internal
 }  // namespace base