Implement SharedMemory::NewAnonymousReadOnly(contents).

base/memory/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_MEMORY_SHARED_MEMORY_H_
 #define BASE_MEMORY_SHARED_MEMORY_H_
 
 #include "build/build_config.h"
 
 #include <string>
 
 #if defined(OS_POSIX)
 #include <stdio.h>
 #include <sys/types.h>
 #include <semaphore.h>
 #endif
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/process/process_handle.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
+#include "base/file_util.h"
 #endif
 
 namespace base {
 
 class FilePath;
 
 // SharedMemoryHandle is a platform specific type which represents
 // the underlying OS handle to a shared memory segment.
 #if defined(OS_WIN)
 typedef HANDLE SharedMemoryHandle;
@@ skipping 39 matching lines @@
 
 #if defined(OS_WIN)
   // Similar to the default constructor, except that this allows for
   // calling Lock() to acquire the named mutex before either Create or Open
   // are called on Windows.
   explicit SharedMemory(const std::wstring& name);
 #endif
 
   // Create a new SharedMemory object from an existing, open
   // shared memory file.
+  //
+  // WARNING: This does not reduce the OS-level permissions on the handle; it
+  // only affects how the SharedMemory will be mmapped.  Use
+  // ShareReadOnlyToProcess to drop permissions.  TODO(jln,jyasskin): DCHECK
+  // that |read_only| matches the permissions of the handle.
   SharedMemory(SharedMemoryHandle handle, bool read_only);
 
   // Create a new SharedMemory object from an existing, open
   // shared memory file that was created by a remote process and not shared
   // to the current process.
   SharedMemory(SharedMemoryHandle handle, bool read_only,
                ProcessHandle process);
 
   // Closes any open files.
   ~SharedMemory();
@@ skipping 89 matching lines @@
   // are technically only unique to a single filesystem. However, we always
   // allocate shared memory backing files from the same directory, so will end
   // up on the same filesystem.
   SharedMemoryId id() const { return inode_; }
 #endif
 
   // Closes the open shared memory segment.
   // It is safe to call Close repeatedly.
   void Close();
 
+  // Shares the shared memory to another process.  Attempts to create a
+  // platform-specific new_handle which can be used in a remote process to read
+  // the shared memory file.  new_handle is an output parameter to receive the
+  // handle for use in the remote process.
+  //
+  // |*this| must have been initialized using one of the Create*() or Open()
+  // methods.  If it was constructed from a SharedMemoryHandle, this call will
+  // CHECK-fail.
+  //
+  // Returns true on success, false otherwise.
+  bool ShareReadOnlyToProcess(ProcessHandle process,
+                              SharedMemoryHandle* new_handle) {
+    return ShareToProcessCommon(process, new_handle, false, SHARE_READONLY);
+  }
+
+  // Logically equivalent to:
+  //   bool ok = ShareReadOnlyToProcess(process, new_handle);
+  //   Close();
+  //   return ok;
+  // Note that the memory is unmapped by calling this method, regardless of the
+  // return value.
+  bool GiveReadOnlyToProcess(ProcessHandle process,
+                             SharedMemoryHandle* new_handle) {
+    return ShareToProcessCommon(process, new_handle, true, SHARE_READONLY);
+  }
+
   // Shares the shared memory to another process.  Attempts
   // to create a platform-specific new_handle which can be
   // used in a remote process to access the shared memory
-  // file.  new_handle is an ouput parameter to receive
+  // file.  new_handle is an output parameter to receive
   // the handle for use in the remote process.
   // Returns true on success, false otherwise.
   bool ShareToProcess(ProcessHandle process,
                       SharedMemoryHandle* new_handle) {
-    return ShareToProcessCommon(process, new_handle, false);
+    return ShareToProcessCommon(process, new_handle, false, SHARE_CURRENT_MODE);
   }
 
   // Logically equivalent to:
   //   bool ok = ShareToProcess(process, new_handle);
   //   Close();
   //   return ok;
   // Note that the memory is unmapped by calling this method, regardless of the
   // return value.
   bool GiveToProcess(ProcessHandle process,
                      SharedMemoryHandle* new_handle) {
-    return ShareToProcessCommon(process, new_handle, true);
+    return ShareToProcessCommon(process, new_handle, true, SHARE_CURRENT_MODE);
   }
 
   // Locks the shared memory.
   //
   // WARNING: on POSIX the memory locking primitive only works across
   // processes, not across threads.  The Lock method is not currently
   // used in inner loops, so we protect against multiple threads in a
   // critical section using a class global lock.
   void Lock();
 
 #if defined(OS_WIN)
   // A Lock() implementation with a timeout that also allows setting
   // security attributes on the mutex. sec_attr may be NULL.
   // Returns true if the Lock() has been acquired, false if the timeout was
   // reached.
   bool Lock(uint32 timeout_ms, SECURITY_ATTRIBUTES* sec_attr);
 #endif
 
   // Releases the shared memory lock.
   void Unlock();
 
  private:
 #if defined(OS_POSIX) && !defined(OS_NACL)
-  bool PrepareMapFile(FILE *fp);
+  bool PrepareMapFile(file_util::ScopedFILE fp, file_util::ScopedFD readonly);
   bool FilePathForMemoryName(const std::string& mem_name, FilePath* path);
   void LockOrUnlockCommon(int function);
 #endif
+  enum ShareMode {
+    SHARE_READONLY,
+    SHARE_CURRENT_MODE,
+  };
   bool ShareToProcessCommon(ProcessHandle process,
                             SharedMemoryHandle* new_handle,
-                            bool close_self);
+                            bool close_self,
+                            ShareMode);
 
 #if defined(OS_WIN)
   std::wstring       name_;
   HANDLE             mapped_file_;
 #elif defined(OS_POSIX)
   int                mapped_file_;
+  int                readonly_mapped_file_;
   ino_t              inode_;
 #endif
   size_t             mapped_size_;
   void*              memory_;
   bool               read_only_;
   size_t             requested_size_;
 #if !defined(OS_POSIX)
   SharedMemoryLock   lock_;
 #endif
 
@@ skipping 14 matching lines @@
   }
 
  private:
   SharedMemory* shared_memory_;
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryAutoLock);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_SHARED_MEMORY_H_