Make SharedMemory track the size that was actually mapped

base/shared_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.
 
 #include "base/basictypes.h"
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
@@ skipping 179 matching lines @@
                    << Time::Now().ToDoubleT();
   std::string test_name = test_name_stream.str();
 
   // Open two handles to a memory segment and check that open_existing works
   // as expected.
   SharedMemory memory1;
   bool rv = memory1.CreateNamed(test_name, false, kDataSize);
   EXPECT_TRUE(rv);
 
   // Memory1 knows it's size because it created it.
-  EXPECT_EQ(memory1.created_size(), kDataSize);
+  EXPECT_EQ(memory1.requested_size(), kDataSize);
 
   rv = memory1.Map(kDataSize);
   EXPECT_TRUE(rv);
 
+  // The mapped memory1 must be at least the size we asked for.
+  EXPECT_GE(memory1.mapped_size(), kDataSize);
+
+  // The mapped memory1 shouldn't exceed rounding for allocation granularity.
+  EXPECT_LT(memory1.mapped_size(),
+            kDataSize + base::SysInfo::VMAllocationGranularity());
+
   memset(memory1.memory(), 'G', kDataSize);
 
   SharedMemory memory2;
   // Should not be able to create if openExisting is false.
   rv = memory2.CreateNamed(test_name, false, kDataSize2);
   EXPECT_FALSE(rv);
 
   // Should be able to create with openExisting true.
   rv = memory2.CreateNamed(test_name, true, kDataSize2);
   EXPECT_TRUE(rv);
 
   // Memory2 shouldn't know the size because we didn't create it.
-  EXPECT_EQ(memory2.created_size(), 0U);
+  EXPECT_EQ(memory2.requested_size(), 0U);
 
   // We should be able to map the original size.
   rv = memory2.Map(kDataSize);
   EXPECT_TRUE(rv);
 
+  // The mapped memory2 must be at least the size of the original.
+  EXPECT_GE(memory2.mapped_size(), kDataSize);
+
+  // The mapped memory2 shouldn't exceed rounding for allocation granularity.
+  EXPECT_LT(memory2.mapped_size(),
+            kDataSize2 + base::SysInfo::VMAllocationGranularity());
+
   // Verify that opening memory2 didn't truncate or delete memory 1.
   char *start_ptr = static_cast<char *>(memory2.memory());
   char *end_ptr = start_ptr + kDataSize;
   for (char* ptr = start_ptr; ptr < end_ptr; ptr++) {
     EXPECT_EQ(*ptr, 'G');
   }
 
   memory1.Close();
   memory2.Close();
 
@@ skipping 142 matching lines @@
 // Create a shared memory object, mmap it, and mprotect it to PROT_EXEC.
 TEST(SharedMemoryTest, AnonymousExecutable) {
   const uint32 kTestSize = 1 << 16;
 
   SharedMemory shared_memory;
   SharedMemoryCreateOptions options;
   options.size = kTestSize;
   options.executable = true;
 
   EXPECT_TRUE(shared_memory.Create(options));
-  EXPECT_TRUE(shared_memory.Map(shared_memory.created_size()));
+  EXPECT_TRUE(shared_memory.Map(shared_memory.requested_size()));
 
-  EXPECT_EQ(0, mprotect(shared_memory.memory(), shared_memory.created_size(),
+  EXPECT_EQ(0, mprotect(shared_memory.memory(), shared_memory.requested_size(),
                         PROT_READ | PROT_EXEC));
 }
 #endif
 
 // Map() will return addresses which are aligned to the platform page size, this
 // varies from platform to platform though.  Since we'd like to advertise a
 // minimum alignment that callers can count on, test for it here.
 TEST(SharedMemoryTest, MapMinimumAlignment) {
   static const int kDataSize = 8192;
 
@@ skipping 71 matching lines @@
   SharedMemoryProcessTest::CleanUp();
 }
 
 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }
 
 #endif  // !OS_IOS
 
 }  // namespace base