Add methods to base::SharedMemory to replace common SharedMemoryHandle operations.

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>
@@ skipping 90 matching lines @@
   DCHECK_GE(handle.fd, 0);
   if (close(handle.fd) < 0)
     DPLOG(ERROR) << "close";
 }
 
 // static
 size_t SharedMemory::GetHandleLimit() {
   return base::GetMaxFds();
 }
 
+#if defined(OS_WIN) || defined(OS_POSIX)

[Nico, 2015/05/29 06:50:23]

this is just "everywhere", right?

[erikchen, 2015/05/29 18:30:24]

I guess so. Removed preprocessor conditionals.

+// static
+SharedMemoryHandle SharedMemory::ShallowCopyOfHandle(
+    const SharedMemoryHandle& handle) {
+  return handle;

[Nico, 2015/05/29 06:50:24]

The CL you link to doesn't modify this function. Is it necessary to wrap this,
or can callers just use " = "? Assignment of handles is fairly well understood,
I feel.

[erikchen, 2015/05/29 18:30:24]

I think it's semantically important to not use assignment of handles, since it
loses information about whether the copy is intended to be shallow or deep. For
example, right now, on POSIX, SharedMemoryHandle is typedefed to FileDescriptor,
and assignment copies the "auto_close" parameter without duping the fd, which
semantically doesn't make any sense. (The existing code happens to work because
locations that make shallow copies of SharedMemoryHandle end up dup()ing the
handle before turning it into a base::SharedMemory.

I updated the definition to fix the "auto_close" bug.

+}
+#endif
+
+#if defined(OS_POSIX)
+// static
+SharedMemoryHandle SharedMemory::DeepCopyOfHandle(

[Nico, 2015/05/29 06:50:24]

CloneHandle() maybe?

[erikchen, 2015/05/29 18:30:24]

If you really want me to change the verb, the canonical verb we use in Chrome is
"Duplicate" when it comes to SharedMemoryHandles. That being said, that verb is
less explicit about shallow/deep copy, which is why I prefer this version.

+    const SharedMemoryHandle& handle,
+    bool clean_up_resources_on_destruction) {
+  int duped_handle = HANDLE_EINTR(dup(handle.fd));
+  if (duped_handle < 0)
+    return base::SharedMemory::NULLHandle();
+  return base::FileDescriptor(duped_handle, clean_up_resources_on_destruction);
+}
+#endif
+
 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
   return CreateAnonymous(size) && Map(size);
 }
 
 #if !defined(OS_ANDROID)
 // 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
@@ skipping 372 matching lines @@
 
   if (close_self) {
     Unmap();
     Close();
   }
 
   return true;
 }
 
 }  // namespace base