Make SharedMemory track the size that was actually mapped

base/shared_memory.h

 // 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.
 
 #ifndef BASE_SHARED_MEMORY_H_
 #define BASE_SHARED_MEMORY_H_
 
 #include "build/build_config.h"
 
 #include <string>
@@ skipping 141 matching lines @@
   // memory block to map.
   // |offset| must be alignent to value of |SysInfo::VMAllocationGranularity()|.
   bool MapAt(off_t offset, size_t bytes);
   enum { MAP_MINIMUM_ALIGNMENT = 32 };
 
   // Unmaps the shared memory from the caller's address space.
   // Returns true if successful; returns false on error or if the
   // memory is not mapped.
   bool Unmap();
 
-  // Get the size of the shared memory backing file.
-  // Note:  This size is only available to the creator of the
-  // shared memory, and not to those that opened shared memory
-  // created externally.
-  // Returns 0 if not created or unknown.
-  // Deprecated method, please keep track of the size yourself if you created
-  // it.
-  // http://crbug.com/60821
-  size_t created_size() const { return created_size_; }
+  // The size requested when the map is first created.
+  size_t requested_size() const { return requested_size_; }
+
+  // The actual size of the mapped memory (may be larger than requested).
+  size_t mapped_size() const { return mapped_size_; }
 
   // Gets a pointer to the opened memory space if it has been
   // Mapped via Map().  Returns NULL if it is not mapped.
   void *memory() const { return memory_; }
 
   // Returns the underlying OS handle for this segment.
   // Use of this handle for anything other than an opaque
   // identifier is not portable.
   SharedMemoryHandle handle() const;
 
@@ skipping 58 matching lines @@
 #endif
   bool ShareToProcessCommon(ProcessHandle process,
                             SharedMemoryHandle* new_handle,
                             bool close_self);
 
 #if defined(OS_WIN)
   std::wstring       name_;
   HANDLE             mapped_file_;
 #elif defined(OS_POSIX)
   int                mapped_file_;
-  size_t             mapped_size_;
   ino_t              inode_;
 #endif
+  size_t             mapped_size_;
   void*              memory_;
   bool               read_only_;
-  size_t             created_size_;
+  size_t             requested_size_;
 #if !defined(OS_POSIX)
   SharedMemoryLock   lock_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemory);
 };
 
 // A helper class that acquires the shared memory lock while
 // the SharedMemoryAutoLock is in scope.
 class SharedMemoryAutoLock {
  public:
   explicit SharedMemoryAutoLock(SharedMemory* shared_memory)
       : shared_memory_(shared_memory) {
     shared_memory_->Lock();
   }
 
   ~SharedMemoryAutoLock() {
     shared_memory_->Unlock();
   }
 
  private:
   SharedMemory* shared_memory_;
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryAutoLock);
 };
 
 }  // namespace base
 
 #endif  // BASE_SHARED_MEMORY_H_