posix: clean up shared memory code

base/shared_memory_posix.cc

 // Copyright (c) 2006-2008 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 78 matching lines @@
     return false;
 
   max_size_ = size;
   return true;
 }
 
 // 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::wstring& name) {
-  std::wstring mem_filename;
-  if (FilenameForMemoryName(name, &mem_filename) == false)
+  FilePath path;
+  if (!FilePathForMemoryName(name, &path))
     return false;
 
-  FilePath path(WideToUTF8(mem_filename));
   if (file_util::PathExists(path)) {
     return file_util::Delete(path, false);
   }
 
   // Doesn't exist, so success.
   return true;
 }
 
 bool SharedMemory::Open(const std::wstring &name, bool read_only) {
   read_only_ = read_only;
 
   int posix_flags = 0;
   posix_flags |= read_only ? O_RDONLY : O_RDWR;
 
   return CreateOrOpen(name, posix_flags, 0);
 }
 
 // For the given shmem named |memname|, return a filename to mmap()
 // (and possibly create).  Modifies |filename|.  Return false on
 // error, or true of we are happy.
-bool SharedMemory::FilenameForMemoryName(const std::wstring &memname,
-                                         std::wstring *filename) {
-  std::wstring mem_filename;
-
+bool SharedMemory::FilePathForMemoryName(const std::wstring& memname,
+                                         FilePath* path) {
   // mem_name will be used for a filename; make sure it doesn't
   // contain anything which will confuse us.
   DCHECK(memname.find_first_of(L"/") == std::string::npos);
   DCHECK(memname.find_first_of(L"\0") == std::string::npos);
 
   FilePath temp_dir;
   if (file_util::GetShmemTempDir(&temp_dir) == false)
     return false;
 
-  mem_filename = UTF8ToWide(temp_dir.value());
-  file_util::AppendToPath(&mem_filename, L"com.google.chrome.shmem." + memname);
-  *filename = mem_filename;
+  *path = temp_dir.AppendASCII("com.google.chrome.shmem." +
+                               WideToASCII(memname));
   return true;
 }
 
 // Chromium mostly only use 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 FilenameForMemoryName().
+// of mem_filename after FilePathForMemoryName().
 bool SharedMemory::CreateOrOpen(const std::wstring &name,
                                 int posix_flags, size_t size) {
   DCHECK(mapped_file_ == -1);
 
   file_util::ScopedFILE file_closer;
   FILE *fp;
 
+  FilePath path;
   if (name == L"") {
     // It doesn't make sense to have a read-only private piece of shmem
     DCHECK(posix_flags & (O_RDWR | O_WRONLY));
 
-    FilePath path;
+    // Q: Why not use the shm_open() etc. APIs?
+    // A: Because they're limited to 4mb on OS X.  FFFFFFFUUUUUUUUUUU
     fp = file_util::CreateAndOpenTemporaryShmemFile(&path);
 
     // Deleting the file prevents anyone else from mapping it in
     // (making it private), and prevents the need for cleanup (once
     // the last fd is closed, it is truly freed).
     file_util::Delete(path, false);
   } else {
-    std::wstring mem_filename;
-    if (FilenameForMemoryName(name, &mem_filename) == false)
+    if (!FilePathForMemoryName(name, &path))
       return false;
 
     std::string mode;
     switch (posix_flags) {
       case (O_RDWR | O_CREAT):
         // Careful: "w+" will truncate if it already exists.
         mode = "a+";
         break;
       case O_RDWR:
         mode = "r+";
         break;
       case O_RDONLY:
         mode = "r";
         break;
       default:
         NOTIMPLEMENTED();
         break;
     }
 
-    fp = file_util::OpenFile(mem_filename, mode.c_str());
+    fp = file_util::OpenFile(path, mode.c_str());
   }
 
-  if (fp == NULL)
+  if (fp == NULL) {
+    if (posix_flags & O_CREAT)
+      LOG(ERROR) << "Creating shared memory in " << path.value() << " failed: "
+                 << strerror(errno);
     return false;
+  }
+
   file_closer.reset(fp);  // close when we go out of scope
 
   // Make sure the (new) file is the right size.
   if (size && (posix_flags & (O_RDWR | O_CREAT))) {
     // Get current size.
     struct stat stat;
     if (fstat(fileno(fp), &stat) != 0)
       return false;
     const size_t current_size = stat.st_size;
     if (current_size != size) {
@@ skipping 96 matching lines @@
 
 void SharedMemory::Unlock() {
   LockOrUnlockCommon(F_ULOCK);
 }
 
 SharedMemoryHandle SharedMemory::handle() const {
   return FileDescriptor(mapped_file_, false);
 }
 
 }  // namespace base