Factor fd sharing code in proxy and fix fd issues once and for all.

ppapi/proxy/ppb_audio_proxy.cc

 // Copyright (c) 2011 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 "ppapi/proxy/ppb_audio_proxy.h"
 
 #include "base/threading/simple_thread.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/trusted/ppb_audio_trusted.h"
@@ skipping 111 matching lines @@
   &GetCurrentConfiguration,
   &StartPlayback,
   &StopPlayback
 };
 
 InterfaceProxy* CreateAudioProxy(Dispatcher* dispatcher,
                                  const void* target_interface) {
   return new PPB_Audio_Proxy(dispatcher, target_interface);
 }
 
+base::PlatformFile IntToPlatformFile(int32_t handle) {
+  // TODO(piman/brettw): Change trusted interface to return a PP_FileHandle,
+  // those casts are ugly.
+#if defined(OS_WIN)
+  return reinterpret_cast<HANDLE>(static_cast<intptr_t>(handle));
+#elif defined(OS_POSIX)
+  return handle;
+#else
+  #error Not implemented.
+#endif
+}
+
 }  // namespace
 
 PPB_Audio_Proxy::PPB_Audio_Proxy(Dispatcher* dispatcher,
                                  const void* target_interface)
     : InterfaceProxy(dispatcher, target_interface),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 PPB_Audio_Proxy::~PPB_Audio_Proxy() {
 }
@@ skipping 77 matching lines @@
   }
   object->SetStreamInfo(
       handle, length, IPC::PlatformFileForTransitToPlatformFile(socket_handle));
 }
 
 void PPB_Audio_Proxy::AudioChannelConnected(
     int32_t result,
     const HostResource& resource) {
   IPC::PlatformFileForTransit socket_handle =
       IPC::InvalidPlatformFileForTransit();
-#if defined(OS_WIN)
-  base::SharedMemoryHandle shared_memory = NULL;
-#elif defined(OS_POSIX)
-  base::SharedMemoryHandle shared_memory(-1, false);
-#else
-  #error Not implemented.
-#endif
+  base::SharedMemoryHandle shared_memory = IPC::InvalidPlatformFileForTransit();
   uint32_t shared_memory_length = 0;
 
   int32_t result_code = result;
   if (result_code == PP_OK) {
     result_code = GetAudioConnectedHandles(resource, &socket_handle,
                                            &shared_memory,
                                            &shared_memory_length);
   }
 
   // Send all the values, even on error. This simplifies some of our cleanup
@@ skipping 18 matching lines @@
   if (!audio_trusted)
     return PP_ERROR_NOINTERFACE;
 
   // Get the socket handle for signaling.
   int32_t socket_handle;
   int32_t result = audio_trusted->GetSyncSocket(resource.host_resource(),
                                                 &socket_handle);
   if (result != PP_OK)
     return result;
 
-#if defined(OS_WIN)
-  // On Windows, duplicate the socket into the plugin process, this will
-  // automatically close the source handle.
-  ::DuplicateHandle(
-      GetCurrentProcess(),
-      reinterpret_cast<HANDLE>(static_cast<intptr_t>(socket_handle)),
-      dispatcher()->remote_process_handle(), foreign_socket_handle,
-      STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ | FILE_MAP_WRITE,
-      FALSE, DUPLICATE_CLOSE_SOURCE);
-#else
-  // On Posix, the socket handle will be auto-duplicated when we send the
-  // FileDescriptor. Don't set AutoClose since this is not our handle.
-  *foreign_socket_handle = base::FileDescriptor(socket_handle, false);
-#endif
+  *foreign_socket_handle = dispatcher()->ShareHandleWithRemote(

[viettrungluu, 2011/02/25 01:25:03]

Could you add a comment that the handle doesn't belong to us?

+      IntToPlatformFile(socket_handle), false);
+  if (*foreign_socket_handle == IPC::InvalidPlatformFileForTransit())
+    return PP_ERROR_FAILED;
 
   // Get the shared memory for the buffer.
-  // TODO(brettw) remove the reinterpret cast when the interface is updated.
   int shared_memory_handle;
   result = audio_trusted->GetSharedMemory(resource.host_resource(),
                                           &shared_memory_handle,
                                           shared_memory_length);
   if (result != PP_OK)
     return result;
 
-  base::SharedMemory shared_memory(
-#if defined(OS_WIN)
-      reinterpret_cast<HANDLE>(static_cast<intptr_t>(shared_memory_handle)),
-#else
-      base::FileDescriptor(shared_memory_handle, false),
-#endif
-      false);
-
-  // Duplicate the shared memory to the plugin process. This will automatically
-  // close the source handle.
-  if (!shared_memory.GiveToProcess(dispatcher()->remote_process_handle(),
-                                   foreign_shared_memory_handle))
+  *foreign_shared_memory_handle = dispatcher()->ShareHandleWithRemote(
+      IntToPlatformFile(shared_memory_handle), false);
+  if (*foreign_shared_memory_handle == IPC::InvalidPlatformFileForTransit())
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace pp