Make SharedMemoryHandle a class on Mac.

base/memory/shared_memory_mac.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/memory/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
@@ skipping 11 matching lines @@
 #include "base/scoped_generic.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/foundation_util.h"
 #endif  // OS_MACOSX
 
-#if defined(OS_ANDROID)
-#include "base/os_compat_android.h"
-#include "third_party/ashmem/ashmem.h"
-#endif
-
 namespace base {
 
 namespace {
 
 LazyInstance<Lock>::Leaky g_thread_lock_ = LAZY_INSTANCE_INITIALIZER;
 
 struct ScopedPathUnlinkerTraits {
   static FilePath* InvalidValue() { return nullptr; }
 
   static void Free(FilePath* path) {
     // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/466437
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "466437 SharedMemory::Create::Unlink"));
     if (unlink(path->value().c_str()))
       PLOG(WARNING) << "unlink";
   }
 };
 
 // Unlinks the FilePath when the object is destroyed.
 typedef ScopedGeneric<FilePath*, ScopedPathUnlinkerTraits> ScopedPathUnlinker;
 
-#if !defined(OS_ANDROID)
 // Makes a temporary file, fdopens it, and then unlinks it. |fp| is populated
 // with the fdopened FILE. |readonly_fd| is populated with the opened fd if
 // options.share_read_only is true. |path| is populated with the location of
 // the file before it was unlinked.
 // Returns false if there's an unhandled failure.
 bool CreateAnonymousSharedMemory(const SharedMemoryCreateOptions& options,
                                  ScopedFILE* fp,
                                  ScopedFD* readonly_fd,
                                  FilePath* path) {
   // It doesn't make sense to have a open-existing private piece of shmem
@@ skipping 28 matching lines @@
       readonly_fd->reset(HANDLE_EINTR(open(path->value().c_str(), O_RDONLY)));
       if (!readonly_fd->is_valid()) {
         DPLOG(ERROR) << "open(\"" << path->value() << "\", O_RDONLY) failed";
         fp->reset();
         return false;
       }
     }
   }
   return true;
 }
-#endif  // !defined(OS_ANDROID)
 }
 
 SharedMemory::SharedMemory()
     : mapped_file_(-1),
       readonly_mapped_file_(-1),
       mapped_size_(0),
       memory_(NULL),
       read_only_(false),
       requested_size_(0) {
 }
 
-SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
-    : mapped_file_(handle.fd),
+SharedMemory::SharedMemory(const SharedMemoryHandle& handle, bool read_only)
+    : mapped_file_(GetFdFromSharedMemoryHandle(handle)),
       readonly_mapped_file_(-1),
       mapped_size_(0),
       memory_(NULL),
       read_only_(read_only),
       requested_size_(0) {
 }
 
-SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
+SharedMemory::SharedMemory(const SharedMemoryHandle& handle,
+                           bool read_only,
                            ProcessHandle process)
-    : mapped_file_(handle.fd),
+    : mapped_file_(GetFdFromSharedMemoryHandle(handle)),
       readonly_mapped_file_(-1),
       mapped_size_(0),
       memory_(NULL),
       read_only_(read_only),
       requested_size_(0) {
   // We don't handle this case yet (note the ignored parameter); let's die if
   // someone comes calling.
   NOTREACHED();
 }
 
 SharedMemory::~SharedMemory() {
   Unmap();
   Close();
 }
 
 // static
 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
-  return handle.fd >= 0;
+  return GetFdFromSharedMemoryHandle(handle) >= 0;
 }
 
 // static
 SharedMemoryHandle SharedMemory::NULLHandle() {
   return SharedMemoryHandle();
 }
 
 // static
 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
-  DCHECK_GE(handle.fd, 0);
-  if (close(handle.fd) < 0)
+  DCHECK_GE(GetFdFromSharedMemoryHandle(handle), 0);
+  if (close(GetFdFromSharedMemoryHandle(handle)) < 0)
     DPLOG(ERROR) << "close";
 }
 
 // static
 size_t SharedMemory::GetHandleLimit() {
   return base::GetMaxFds();
 }
 
 // static
 SharedMemoryHandle SharedMemory::DuplicateHandle(
     const SharedMemoryHandle& handle) {
-  int duped_handle = HANDLE_EINTR(dup(handle.fd));
-  if (duped_handle < 0)
-    return base::SharedMemory::NULLHandle();
-  return base::FileDescriptor(duped_handle, true);
+  return handle.Duplicate();
 }
 
 // static
 int SharedMemory::GetFdFromSharedMemoryHandle(
     const SharedMemoryHandle& handle) {
-  return handle.fd;
+  return handle.GetFileDescriptor()->fd;
 }
 
 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
-#if !defined(OS_ANDROID)
 // static
 int SharedMemory::GetSizeFromSharedMemoryHandle(
     const SharedMemoryHandle& handle) {
   struct stat st;
-  if (fstat(handle.fd, &st) != 0)
+  if (fstat(GetFdFromSharedMemoryHandle(handle), &st) != 0)
     return -1;
   return st.st_size;
 }
 
 // Chromium mostly only uses the unique/private shmem as specified by
 // "name == L"". The exception is in the StatsTable.
 // TODO(jrg): there is no way to "clean up" all unused named shmem if
 // we restart from a crash.  (That isn't a new problem, but it is a problem.)
 // In case we want to delete it later, it may be useful to save the value
 // of mem_filename after FilePathForMemoryName().
@@ skipping 86 matching lines @@
     if (fstat(fileno(fp.get()), &stat) != 0)
       return false;
     const size_t current_size = stat.st_size;
     if (current_size != options.size) {
       if (HANDLE_EINTR(ftruncate(fileno(fp.get()), options.size)) != 0)
         return false;
     }
     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.";
-      }
-    }
-#else
-    PLOG(ERROR) << "Creating shared memory in " << path.value() << " failed";
-#endif
     return false;
   }
 
   return PrepareMapFile(fp.Pass(), readonly_fd.Pass());
 }
 
 // Our current implementation of shmem is with mmap()ing of files.
 // These files need to be deleted explicitly.
 // In practice this call is only needed for unit tests.
 bool SharedMemory::Delete(const std::string& name) {
@@ skipping 17 matching lines @@
 
   const char *mode = read_only ? "r" : "r+";
   ScopedFILE fp(base::OpenFile(path, mode));
   ScopedFD readonly_fd(HANDLE_EINTR(open(path.value().c_str(), O_RDONLY)));
   if (!readonly_fd.is_valid()) {
     DPLOG(ERROR) << "open(\"" << path.value() << "\", O_RDONLY) failed";
     return false;
   }
   return PrepareMapFile(fp.Pass(), readonly_fd.Pass());
 }
-#endif  // !defined(OS_ANDROID)
 
 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
   if (mapped_file_ == -1)
     return false;
 
   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
     return false;
 
   if (memory_)
     return false;
 
-#if defined(OS_ANDROID)
-  // On Android, Map can be called with a size and offset of zero to use the
-  // ashmem-determined size.
-  if (bytes == 0) {
-    DCHECK_EQ(0, offset);
-    int ashmem_bytes = ashmem_get_size_region(mapped_file_);
-    if (ashmem_bytes < 0)
-      return false;
-    bytes = 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) {
     mapped_size_ = bytes;
     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
   } else {
     memory_ = NULL;
   }
 
   return mmap_succeeded;
 }
 
 bool SharedMemory::Unmap() {
   if (memory_ == NULL)
     return false;
 
   munmap(memory_, mapped_size_);
   memory_ = NULL;
   mapped_size_ = 0;
   return true;
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
-  return FileDescriptor(mapped_file_, false);
+  return SharedMemoryHandle(FileDescriptor(mapped_file_, false));
 }
 
 void SharedMemory::Close() {
   if (mapped_file_ > 0) {
     if (close(mapped_file_) < 0)
       PLOG(ERROR) << "close";
     mapped_file_ = -1;
   }
   if (readonly_mapped_file_ > 0) {
     if (close(readonly_mapped_file_) < 0)
       PLOG(ERROR) << "close";
     readonly_mapped_file_ = -1;
   }
 }
 
 void SharedMemory::LockDeprecated() {
   g_thread_lock_.Get().Acquire();
   LockOrUnlockCommon(F_LOCK);
 }
 
 void SharedMemory::UnlockDeprecated() {
   LockOrUnlockCommon(F_ULOCK);
   g_thread_lock_.Get().Release();
 }
 
-#if !defined(OS_ANDROID)
 bool SharedMemory::PrepareMapFile(ScopedFILE fp, ScopedFD readonly_fd) {

[Nico, 2015/06/17 04:03:21]

There's a lot of code in this file that's just copied without any modifications.
Do you have a preview of how much this file is going to change in follow-ups?

[erikchen, 2015/06/17 17:38:55]

I don't have a preview to show you, but pretty much everything is changing.

In the short term, every function has to support both Mach and POSIX backed
shared memory.
In the long term, every function will only support Mach backed shared memory.

   DCHECK_EQ(-1, mapped_file_);
   DCHECK_EQ(-1, readonly_mapped_file_);
   if (fp == NULL)
     return false;
 
   // This function theoretically can block on the disk, but realistically
   // the temporary files we create will just go into the buffer cache
   // and be deleted before they ever make it out to disk.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
@@ skipping 31 matching lines @@
                                          FilePath* path) {
   // mem_name will be used for a filename; make sure it doesn't
   // contain anything which will confuse us.
   DCHECK_EQ(std::string::npos, mem_name.find('/'));
   DCHECK_EQ(std::string::npos, mem_name.find('\0'));
 
   FilePath temp_dir;
   if (!GetShmemTempDir(false, &temp_dir))
     return false;
 
-#if !defined(OS_MACOSX)
-#if defined(GOOGLE_CHROME_BUILD)
-  std::string name_base = std::string("com.google.Chrome");
-#else
-  std::string name_base = std::string("org.chromium.Chromium");
-#endif
-#else  // OS_MACOSX
   std::string name_base = std::string(base::mac::BaseBundleID());
-#endif  // OS_MACOSX
   *path = temp_dir.AppendASCII(name_base + ".shmem." + mem_name);
   return true;
 }
-#endif  // !defined(OS_ANDROID)
 
 void SharedMemory::LockOrUnlockCommon(int function) {
   DCHECK_GE(mapped_file_, 0);
   while (lockf(mapped_file_, function, 0) < 0) {
     if (errno == EINTR) {
       continue;
     } else if (errno == ENOLCK) {
       // temporary kernel resource exaustion
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(500));
       continue;
@@ skipping 23 matching lines @@
       handle_to_dup = readonly_mapped_file_;
       break;
   }
 
   const int new_fd = HANDLE_EINTR(dup(handle_to_dup));
   if (new_fd < 0) {
     DPLOG(ERROR) << "dup() failed.";
     return false;
   }
 
-  new_handle->fd = new_fd;
-  new_handle->auto_close = true;
+  new_handle->SetFileHandle(new_fd, true);
 
   if (close_self) {
     Unmap();
     Close();
   }
 
   return true;
 }
 
 }  // namespace base