make base::SharedMemoryHandle a class on POSIX.

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>
 
@@ skipping 11 matching lines @@
 #endif
 
 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)
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  return ScopedPlatformHandle(PlatformHandle(memory_handle.GetMemoryObject()));
+#else
   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);
@@ skipping 93 matching lines @@
     size_t length) {
   DCHECK(IsValidMap(offset, length));
   DCHECK(shared_memory_);
   base::SharedMemoryHandle handle;
   {
     base::AutoLock locker(lock_);
     handle = base::SharedMemory::DuplicateHandle(shared_memory_->handle());
   }
 
   // TODO(crbug.com/706689): Remove this when the bug is sorted out.
-  CHECK(handle != base::SharedMemory::NULLHandle());
+  CHECK(handle.IsValid());
 
-  if (handle == base::SharedMemory::NULLHandle())
+  if (!handle.IsValid())
     return nullptr;
 
   std::unique_ptr<PlatformSharedBufferMapping> mapping(
       new PlatformSharedBufferMapping(handle, read_only_, offset, length));
   if (mapping->Map())
     return base::WrapUnique(mapping.release());
 
   return nullptr;
 }
 
 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())
+  if (!handle.IsValid())
     return ScopedPlatformHandle();
 
   return SharedMemoryToPlatformHandle(handle);
 }
 
 ScopedPlatformHandle PlatformSharedBuffer::PassPlatformHandle() {
   DCHECK(HasOneRef());
 
   // The only way to pass a handle from base::SharedMemory is to duplicate it
   // and close the original.
@@ skipping 11 matching lines @@
   return base::SharedMemory::DuplicateHandle(shared_memory_->handle());
 }
 
 PlatformSharedBuffer* PlatformSharedBuffer::CreateReadOnlyDuplicate() {
   DCHECK(shared_memory_);
 
   if (ro_shared_memory_) {
     base::AutoLock locker(lock_);
     base::SharedMemoryHandle handle;
     handle = base::SharedMemory::DuplicateHandle(ro_shared_memory_->handle());
-    if (handle == base::SharedMemory::NULLHandle())
+    if (!handle.IsValid())
       return nullptr;
     return CreateFromSharedMemoryHandle(num_bytes_, true, handle);
   }
 
   base::SharedMemoryHandle handle;
   bool success;
   {
     base::AutoLock locker(lock_);
     success = shared_memory_->ShareReadOnlyToProcess(
         base::GetCurrentProcessHandle(), &handle);
   }
-  if (!success || handle == base::SharedMemory::NULLHandle())
-      return nullptr;
+  if (!success || !handle.IsValid())
+    return nullptr;
 
   return CreateFromSharedMemoryHandle(num_bytes_, true, handle);
 }
 
 PlatformSharedBuffer::PlatformSharedBuffer(size_t num_bytes, bool read_only)
     : num_bytes_(num_bytes), read_only_(read_only) {}
 
 PlatformSharedBuffer::~PlatformSharedBuffer() {}
 
 bool PlatformSharedBuffer::Init() {
@@ skipping 14 matching lines @@
   DCHECK(!shared_memory_);
 
 #if defined(OS_WIN)
   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);
+  base::SharedMemoryHandle handle(
+      base::FileDescriptor(platform_handle.release().handle, false));
 #endif
 
   shared_memory_.reset(new base::SharedMemory(handle, read_only_));
   return true;
 }
 
 bool PlatformSharedBuffer::InitFromPlatformHandlePair(
     ScopedPlatformHandle rw_platform_handle,
     ScopedPlatformHandle ro_platform_handle) {
 #if defined(OS_MACOSX)
   NOTREACHED();
   return false;
 #else  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
   base::SharedMemoryHandle handle(rw_platform_handle.release().handle,
                                   base::GetCurrentProcId());
   base::SharedMemoryHandle ro_handle(ro_platform_handle.release().handle,
                                      base::GetCurrentProcId());
 #else  // defined(OS_WIN)
-  base::SharedMemoryHandle handle(rw_platform_handle.release().handle, false);
-  base::SharedMemoryHandle ro_handle(ro_platform_handle.release().handle,
-                                     false);
+  base::SharedMemoryHandle handle(
+      base::FileDescriptor(rw_platform_handle.release().handle, false));
+  base::SharedMemoryHandle ro_handle(
+      base::FileDescriptor(ro_platform_handle.release().handle, false));
 #endif  // defined(OS_WIN)
 
   DCHECK(!shared_memory_);
   shared_memory_.reset(new base::SharedMemory(handle, false));
   ro_shared_memory_.reset(new base::SharedMemory(ro_handle, true));
   return true;
 
 #endif  // defined(OS_MACOSX)
 }
 
@@ skipping 47 matching lines @@
   base_ = static_cast<char*>(shared_memory_.memory()) + offset_rounding;
   return true;
 }
 
 void PlatformSharedBufferMapping::Unmap() {
   shared_memory_.Unmap();
 }
 
 }  // namespace edk
 }  // namespace mojo