Prepare gpu_channel_host for SharedMemoryHandles not backed by POSIX fds.

content/common/gpu/client/gpu_channel_host.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 "content/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "url/gurl.h"
 
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(OS_MACOSX)
 #include "content/public/common/sandbox_init.h"
 #endif
 
 using base::AutoLock;
 
 namespace content {
 
 GpuListenerInfo::GpuListenerInfo() {}
 
 GpuListenerInfo::~GpuListenerInfo() {}
@@ skipping 264 matching lines @@
   io_task_runner->PostTask(
       FROM_HERE, base::Bind(&GpuChannelHost::MessageFilter::RemoveRoute,
                             channel_filter_.get(), route_id));
 }
 
 base::SharedMemoryHandle GpuChannelHost::ShareToGpuProcess(
     base::SharedMemoryHandle source_handle) {
   if (IsLost())
     return base::SharedMemory::NULLHandle();
 
-#if defined(OS_WIN)
-  // Windows needs to explicitly duplicate the handle out to another process.
+#if defined(OS_WIN) || defined(OS_MACOSX)
+  // Windows and Mac need to explicitly duplicate the handle out to another
+  // process.
   base::SharedMemoryHandle target_handle;
   base::ProcessId peer_pid;
   {
     AutoLock lock(context_lock_);
     if (!channel_)
       return base::SharedMemory::NULLHandle();
     peer_pid = channel_->GetPeerPID();
   }
-  if (!BrokerDuplicateHandle(source_handle,
-                             peer_pid,
-                             &target_handle,
-                             FILE_GENERIC_READ | FILE_GENERIC_WRITE,
-                             0)) {
+#if defined(OS_WIN)
+  bool success =
+      BrokerDuplicateHandle(source_handle, peer_pid, &target_handle,
+                            FILE_GENERIC_READ | FILE_GENERIC_WRITE, 0);
+#elif defined(OS_MACOSX)
+  bool success = BrokerDuplicateSharedMemoryHandle(source_handle, peer_pid,
+                                                   &target_handle);
+#endif
+  if (!success)
     return base::SharedMemory::NULLHandle();
-  }
 
   return target_handle;
 #else
-  int duped_handle = HANDLE_EINTR(dup(source_handle.fd));
-  if (duped_handle < 0)
-    return base::SharedMemory::NULLHandle();
-
-  return base::FileDescriptor(duped_handle, true);
-#endif
+  return base::SharedMemory::DuplicateHandle(source_handle);
+#endif  // defined(OS_WIN) || defined(OS_MACOSX)
 }
 
 int32 GpuChannelHost::ReserveTransferBufferId() {
   return next_transfer_buffer_id_.GetNext();
 }
 
 gfx::GpuMemoryBufferHandle GpuChannelHost::ShareGpuMemoryBufferToGpuProcess(
     const gfx::GpuMemoryBufferHandle& source_handle,
     bool* requires_sync_point) {
   switch (source_handle.type) {
@@ skipping 94 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content