Change NaCl IPC PPAPI proxy startup to support a NaCl-Browser process

ppapi/proxy/ppb_audio_proxy.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 "ppapi/proxy/ppb_audio_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/threading/simple_thread.h"
 #include "media/audio/shared_memory_util.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/trusted/ppb_audio_trusted.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/api_id.h"
 #include "ppapi/shared_impl/platform_file.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_audio_shared.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/ppb_audio_config_api.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 #include "ppapi/thunk/thunk.h"
 
 using ppapi::IntToPlatformFile;
+using ppapi::proxy::SerializedHandle;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_Audio_API;
 using ppapi::thunk::PPB_AudioConfig_API;
 
 namespace ppapi {
 namespace proxy {
 
 class Audio : public Resource, public PPB_Audio_Shared {
  public:
   Audio(const HostResource& audio_id,
@@ skipping 207 matching lines @@
     result_code = GetAudioConnectedHandles(resource, &socket_handle,
                                            &shared_memory,
                                            &audio_buffer_length);
   }
 
   // Send all the values, even on error. This simplifies some of our cleanup
   // code since the handles will be in the other process and could be
   // inconvenient to clean up. Our IPC code will automatically handle this for
   // us, as long as the remote side always closes the handles it receives
   // (in OnMsgNotifyAudioStreamCreated), even in the failure case.
-  ppapi::proxy::SerializedHandle fd_wrapper(socket_handle);
+  SerializedHandle fd_wrapper(SerializedHandle::SOCKET, socket_handle);
 
   // Note that we must call TotalSharedMemorySizeInBytes because
   // Audio allocates extra space in shared memory for book-keeping, so the
   // actual size of the shared memory buffer is larger than audio_buffer_length.
   // When sending to NaCl, NaClIPCAdapter expects this size to match the size
   // of the full shared memory buffer.
-  ppapi::proxy::SerializedHandle handle_wrapper(
+  SerializedHandle handle_wrapper(
       shared_memory,
       media::TotalSharedMemorySizeInBytes(audio_buffer_length));
   dispatcher()->Send(new PpapiMsg_PPBAudio_NotifyAudioStreamCreated(
       API_ID_PPB_AUDIO, resource, result_code, fd_wrapper, handle_wrapper));
 }
 
 int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
     const HostResource& resource,
     IPC::PlatformFileForTransit* foreign_socket_handle,
     base::SharedMemoryHandle* foreign_shared_memory_handle,
@@ skipping 28 matching lines @@
   if (*foreign_shared_memory_handle == IPC::InvalidPlatformFileForTransit())
     return PP_ERROR_FAILED;
 
   return PP_OK;
 }
 
 // Processed in the plugin (message from host).
 void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
     const HostResource& audio_id,
     int32_t result_code,
-    ppapi::proxy::SerializedHandle socket_handle,
-    ppapi::proxy::SerializedHandle handle) {
+    SerializedHandle socket_handle,
+    SerializedHandle handle) {
   CHECK(socket_handle.is_socket());
   CHECK(handle.is_shmem());
   EnterPluginFromHostResource<PPB_Audio_API> enter(audio_id);
   if (enter.failed() || result_code != PP_OK) {
     // The caller may still have given us these handles in the failure case.
     // The easiest way to clean these up is to just put them in the objects
     // and then close them. This failure case is not performance critical.
     base::SyncSocket temp_socket(
         IPC::PlatformFileForTransitToPlatformFile(socket_handle.descriptor()));
     base::SharedMemory temp_mem(handle.shmem(), false);
   } else {
     // See the comment above about how we must call
     // TotalSharedMemorySizeInBytes to get the actual size of the buffer. Here,
     // we must call PacketSizeInBytes to get back the size of the audio buffer,
     // excluding the bytes that audio uses for book-keeping.
     static_cast<Audio*>(enter.object())->SetStreamInfo(
         enter.resource()->pp_instance(), handle.shmem(),
         media::PacketSizeInBytes(handle.size()),
         IPC::PlatformFileForTransitToPlatformFile(socket_handle.descriptor()));
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi