Make SharedMemory track the size that was actually mapped

base/shared_memory_posix.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/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ skipping 24 matching lines @@
 // Paranoia. Semaphores and shared memory segments should live in different
 // namespaces, but who knows what's out there.
 const char kSemaphoreSuffix[] = "-sem";
 
 LazyInstance<Lock>::Leaky g_thread_lock_ = LAZY_INSTANCE_INITIALIZER;
 
 }
 
 SharedMemory::SharedMemory()
     : mapped_file_(-1),
+      inode_(0),
       mapped_size_(0),
-      inode_(0),
       memory_(NULL),
       read_only_(false),
-      created_size_(0) {
+      requested_size_(0) {
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
     : mapped_file_(handle.fd),
+      inode_(0),
       mapped_size_(0),
-      inode_(0),
       memory_(NULL),
       read_only_(read_only),
-      created_size_(0) {
+      requested_size_(0) {
   struct stat st;
   if (fstat(handle.fd, &st) == 0) {
     // If fstat fails, then the file descriptor is invalid and we'll learn this
     // fact when Map() fails.
     inode_ = st.st_ino;
   }
 }
 
 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
                            ProcessHandle process)
     : mapped_file_(handle.fd),
+      inode_(0),
       mapped_size_(0),
-      inode_(0),
       memory_(NULL),
       read_only_(read_only),
-      created_size_(0) {
+      requested_size_(0) {
   // We don't handle this case yet (note the ignored parameter); let's die if
   // someone comes calling.
   NOTREACHED();
 }
 
 SharedMemory::~SharedMemory() {
   Close();
 }
 
 // static
@@ skipping 72 matching lines @@
       file_util::CloseFile(fp);
       return false;
     }
     const size_t current_size = stat.st_size;
     if (current_size != options.size) {
       if (HANDLE_EINTR(ftruncate(fileno(fp), options.size)) != 0) {
         file_util::CloseFile(fp);
         return false;
       }
     }
-    created_size_ = options.size;
+    requested_size_ = options.size;
   }
   if (fp == NULL) {
 #if !defined(OS_MACOSX)
     PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
     FilePath dir = path.DirName();
     if (access(dir.value().c_str(), W_OK | X_OK) < 0) {
       PLOG(ERROR) << "Unable to access(W_OK|X_OK) " << dir.value();
       if (dir.value() == "/dev/shm") {
         LOG(FATAL) << "This is frequently caused by incorrect permissions on "
                    << "/dev/shm.  Try 'sudo chmod 1777 /dev/shm' to fix.";
@@ skipping 50 matching lines @@
     int ashmem_bytes = ashmem_get_size_region(mapped_file_);
     if (ashmem_bytes < 0)
       return false;
 
     DCHECK_GE(static_cast<uint32>(ashmem_bytes), bytes);
     // The caller wants to determine the map region size from ashmem.
     bytes = ashmem_bytes - offset;
     // TODO(port): we set the created size here so that it is available in
     // transport_dib_android.cc. We should use ashmem_get_size_region()
     // in transport_dib_android.cc.
-    created_size_ = ashmem_bytes;
+    mapped_size_ = ashmem_bytes;
   }
 #endif
 
   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
                  MAP_SHARED, mapped_file_, offset);
 
   bool mmap_succeeded = memory_ != (void*)-1 && memory_ != NULL;
   if (mmap_succeeded) {
+#if !defined(OS_ANDROID)
     mapped_size_ = bytes;
+#endif
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
   } else {
     memory_ = NULL;
   }
 
   return mmap_succeeded;
 }
 
 bool SharedMemory::Unmap() {
@@ skipping 119 matching lines @@
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base