Update from https://crrev.com/333737

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>
@@ skipping 16 matching lines @@
 
 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;
 #elif defined(OS_POSIX)
-// A SharedMemoryId is sufficient to identify a given shared memory segment on a
-// system, but insufficient to map it.
 typedef FileDescriptor SharedMemoryHandle;
-typedef ino_t SharedMemoryId;
 #endif
 
 // Options for creating a shared memory object.
 struct SharedMemoryCreateOptions {
   SharedMemoryCreateOptions()
       : name_deprecated(NULL),
         size(0),
         open_existing_deprecated(false),
         executable(false),
         share_read_only(false) {}
@@ skipping 58 matching lines @@
 
   // Returns invalid handle (see comment above for exact definition).
   static SharedMemoryHandle NULLHandle();
 
   // Closes a shared memory handle.
   static void CloseHandle(const SharedMemoryHandle& handle);
 
   // Returns the maximum number of handles that can be open at once per process.
   static size_t GetHandleLimit();
 
+  // Duplicates The underlying OS primitive. Returns NULLHandle() on failure.
+  // The caller is responsible for destroying the duplicated OS primitive.
+  static SharedMemoryHandle DuplicateHandle(const SharedMemoryHandle& handle);
+
+#if defined(OS_POSIX)
+  // This method requires that the SharedMemoryHandle is backed by a POSIX fd.
+  static int GetFdFromSharedMemoryHandle(const SharedMemoryHandle& handle);
+#endif
+
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
+  // Returns the size of the shared memory region referred to by |handle|.
+  // Returns '-1' on a failure to determine the size.
+  static int GetSizeFromSharedMemoryHandle(const SharedMemoryHandle& handle);
+#endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
+
   // Creates a shared memory object as described by the options struct.
   // Returns true on success and false on failure.
   bool Create(const SharedMemoryCreateOptions& options);
 
   // Creates and maps an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
   bool CreateAndMapAnonymous(size_t size);
 
   // Creates an anonymous shared memory segment of size size.
   // Returns true on success and false on failure.
@@ skipping 56 matching lines @@
 
   // Gets a pointer to the opened memory space if it has been
   // Mapped via Map().  Returns NULL if it is not mapped.
   void *memory() const { return memory_; }
 
   // Returns the underlying OS handle for this segment.
   // Use of this handle for anything other than an opaque
   // identifier is not portable.
   SharedMemoryHandle handle() const;
 
-#if defined(OS_POSIX) && !defined(OS_NACL)
-  // Returns a unique identifier for this shared memory segment. Inode numbers
-  // 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. The memory will remain mapped if
   // it was previously mapped.
   // 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.
   //
@@ skipping 69 matching lines @@
                             SharedMemoryHandle* new_handle,
                             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)
   HANDLE             lock_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemory);
@@ skipping 14 matching lines @@
   }
 
  private:
   SharedMemory* shared_memory_;
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryAutoLockDeprecated);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_SHARED_MEMORY_H_