[mojo-edk] Expose portable API for platform handle wrapping

mojo/edk/embedder/platform_shared_buffer.cc

 // Copyright 2014 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 "mojo/edk/embedder/platform_shared_buffer.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "base/sys_info.h"
 #include "mojo/edk/embedder/platform_handle_utils.h"
 
 namespace mojo {
 namespace edk {
 
-namespace {
-
-// Takes ownership of |memory_handle|.
-ScopedPlatformHandle SharedMemoryToPlatformHandle(
-    base::SharedMemoryHandle memory_handle) {
-#if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
-  return ScopedPlatformHandle(PlatformHandle(memory_handle.fd));
-#elif defined(OS_WIN)
-  return ScopedPlatformHandle(PlatformHandle(memory_handle.GetHandle()));
-#else
-  return ScopedPlatformHandle(PlatformHandle(memory_handle.GetMemoryObject()));
-#endif
-}
-
-}  // namespace
-
 // static
 PlatformSharedBuffer* PlatformSharedBuffer::Create(size_t num_bytes) {
   DCHECK_GT(num_bytes, 0u);
 
   PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, false);
   if (!rv->Init()) {
     // We can't just delete it directly, due to the "in destructor" (debug)
     // check.
     scoped_refptr<PlatformSharedBuffer> deleter(rv);
     return nullptr;
@@ skipping 47 matching lines @@
     bool read_only,
     base::SharedMemoryHandle handle) {
   DCHECK_GT(num_bytes, 0u);
 
   PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, read_only);
   rv->InitFromSharedMemoryHandle(handle);
 
   return rv;
 }
 
+// static
+base::SharedMemoryHandle
+PlatformSharedBuffer::GetSharedMemoryHandleFromPlatformHandle(
+      MojoPlatformHandle platform_handle,
+      size_t size,
+      bool read_only) {
+#if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
+  return base::SharedMemoryHandle(static_cast<int>(platform_handle),
+                                  false);
+#elif defined(OS_WIN)
+  return base::SharedMemoryHandle(static_cast<HANDLE>(platform_handle),
+                                  base::GetCurrentProcessHandle());
+#else
+  return base::SharedMemoryHandle(static_cast<mach_port_t>(platform_handle),
+                                  static_cast<mach_vm_size_t>(num_bytes),
+                                  base::GetCurrentProcId());
+#endif
+}
+
+// static
+PlatformHandle PlatformSharedBuffer::GetPlatformHandleFromSharedMemoryHandle(
+    base::SharedMemoryHandle memory_handle) {
+#if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
+  return PlatformHandle(memory_handle.fd);
+#elif defined(OS_WIN)
+  return PlatformHandle(memory_handle.GetHandle());
+#else
+  return PlatformHandle(memory_handle.GetMemoryObject());
+#endif
+}
+
 size_t PlatformSharedBuffer::GetNumBytes() const {
   return num_bytes_;
 }
 
 bool PlatformSharedBuffer::IsReadOnly() const {
   return read_only_;
 }
 
 std::unique_ptr<PlatformSharedBufferMapping> PlatformSharedBuffer::Map(
     size_t offset,
@@ skipping 40 matching lines @@
 ScopedPlatformHandle PlatformSharedBuffer::DuplicatePlatformHandle() {
   DCHECK(shared_memory_);
   base::SharedMemoryHandle handle;
   {
     base::AutoLock locker(lock_);
     handle = base::SharedMemory::DuplicateHandle(shared_memory_->handle());
   }
   if (handle == base::SharedMemory::NULLHandle())
     return ScopedPlatformHandle();
 
-  return SharedMemoryToPlatformHandle(handle);
+  return ScopedPlatformHandle(GetPlatformHandleFromSharedMemoryHandle(handle));
 }
 
 ScopedPlatformHandle PlatformSharedBuffer::PassPlatformHandle() {
   DCHECK(HasOneRef());
 
   // The only way to pass a handle from base::SharedMemory is to duplicate it
   // and close the original.
   ScopedPlatformHandle handle = DuplicatePlatformHandle();
 
   base::AutoLock locker(lock_);
@@ skipping 48 matching lines @@
   options.share_read_only = true;
 
   shared_memory_.reset(new base::SharedMemory);
   return shared_memory_->Create(options);
 }
 
 bool PlatformSharedBuffer::InitFromPlatformHandle(
     ScopedPlatformHandle platform_handle) {
   DCHECK(!shared_memory_);
 
 #if defined(OS_WIN)

[Anand Mistry (off Chromium), 2016/05/20 06:25:40]

Please change this to use the new function.

[Ken Rockot(use gerrit already), 2016/05/20 22:19:43]

No longer relevant since I removed the new function

   base::SharedMemoryHandle handle(platform_handle.release().handle,
                                   base::GetCurrentProcId());
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   base::SharedMemoryHandle handle;
   handle = base::SharedMemoryHandle(platform_handle.release().port, num_bytes_,
                                     base::GetCurrentProcId());
 #else
   base::SharedMemoryHandle handle(platform_handle.release().handle, false);
 #endif
 
@@ skipping 54 matching lines @@
   base_ = static_cast<char*>(shared_memory_.memory()) + offset_rounding;
   return true;
 }
 
 void PlatformSharedBufferMapping::Unmap() {
   shared_memory_.Unmap();
 }
 
 }  // namespace edk
 }  // namespace mojo