Implement SharedMemory::NewAnonymousReadOnly(contents).

base/memory/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/memory/shared_memory.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/process/process_metrics.h"
 #include "base/safe_strerror_posix.h"
+#include "base/strings/stringprintf.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)
@@ skipping 363 matching lines @@
       NOTREACHED() << "lockf() failed."
                    << " function:" << function
                    << " fd:" << mapped_file_
                    << " errno:" << errno
                    << " msg:" << safe_strerror(errno);
     }
   }
 }
 
 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
-                                        SharedMemoryHandle *new_handle,
-                                        bool close_self) {
-  const int new_fd = dup(mapped_file_);
-  if (new_fd < 0) {
-    DPLOG(ERROR) << "dup() failed.";
-    return false;
+                                        SharedMemoryHandle* new_handle,
+                                        bool close_self,
+                                        ShareMode share_mode) {
+  int new_fd = -1;
+  switch(share_mode) {
+    case SHARE_CURRENT_MODE: {
+      new_fd = dup(mapped_file_);
+      if (new_fd < 0) {
+        DPLOG(ERROR) << "dup() failed.";
+        return false;
+      }
+    } break;
+    case SHARE_READONLY: {
+      const std::string writable_fd_path = StringPrintf(
+#if defined(OS_ANDROID)
+          "/proc/self/fd/%d",
+#else
+          "/dev/fd/%d",
+#endif
+          mapped_file_);
+      new_fd = HANDLE_EINTR(open(writable_fd_path.c_str(), O_RDONLY));

[Jeffrey Yasskin, 2013/10/17 03:00:25]

This approach doesn't work on Apple OSen. 
iOS:
http://build.chromium.org/p/tryserver.chromium/builders/ios_dbg_simulator/bui...
MacOS:
http://build.chromium.org/p/tryserver.chromium/builders/swarm_triggered/build...


[ RUN      ] SharedMemoryTest.ShareReadOnly
/b/build/slave/ios_dbg_simulator/build/src/base/memory/shared_memory_unittest.cc:397:
Failure
Value of: fcntl(handle.fd, 3) & 0x0003
  Actual: 2
Expected: 0x0000
Which is: 0
The descriptor itself should be read-only.
/b/build/slave/ios_dbg_simulator/build/src/base/memory/shared_memory_unittest.cc:408:
Failure
Value of: writable
  Actual: 0x9fee000
Expected: ((void *)-1)
Which is: 0xffffffff
It shouldn't be possible to re-mmap the descriptor writable.


To support Apple, it looks like we need to create the read-only descriptor at
the same time we create the writable one. What API would you like?

+      if (new_fd < 0) {
+        DPLOG(ERROR) << "open(\"" << writable_fd_path << "\", O_RDONLY) failed";
+        return false;
+      }
+    } break;
   }
 
   new_handle->fd = new_fd;
   new_handle->auto_close = true;
 
   if (close_self)
     Close();
 
   return true;
 }
 
 }  // namespace base