ppapi/proxy/ppb_audio_proxy.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/ppb_audio_proxy.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/threading/simple_thread.h"
   9 #include "ppapi/c/pp_errors.h"
  10 #include "ppapi/c/ppb_audio.h"
  11 #include "ppapi/c/ppb_audio_config.h"
  12 #include "ppapi/c/ppb_var.h"
  13 #include "ppapi/proxy/enter_proxy.h"
  14 #include "ppapi/proxy/plugin_dispatcher.h"
  15 #include "ppapi/proxy/ppapi_messages.h"
  16 #include "ppapi/shared_impl/api_id.h"
  17 #include "ppapi/shared_impl/platform_file.h"
  18 #include "ppapi/shared_impl/ppapi_globals.h"
  19 #include "ppapi/shared_impl/ppb_audio_shared.h"
  20 #include "ppapi/shared_impl/resource.h"
  21 #include "ppapi/thunk/ppb_audio_config_api.h"
  22 #include "ppapi/thunk/enter.h"
  23 #include "ppapi/thunk/resource_creation_api.h"
  24 #include "ppapi/thunk/thunk.h"
  25
  26 using ppapi::IntToPlatformFile;
  27 using ppapi::proxy::SerializedHandle;
  28 using ppapi::thunk::EnterResourceNoLock;
  29 using ppapi::thunk::PPB_Audio_API;
  30 using ppapi::thunk::PPB_AudioConfig_API;
  31
  32 namespace ppapi {
  33 namespace proxy {
  34
  35 class Audio : public Resource, public PPB_Audio_Shared {
  36  public:
  37   Audio(const HostResource& audio_id,
  38         PP_Resource config_id,
  39         const AudioCallbackCombined& callback,
  40         void* user_data);
  41   ~Audio() override;
  42
  43   // Resource overrides.
  44   PPB_Audio_API* AsPPB_Audio_API() override;
  45
  46   // PPB_Audio_API implementation.
  47   PP_Resource GetCurrentConfig() override;
  48   PP_Bool StartPlayback() override;
  49   PP_Bool StopPlayback() override;
  50   int32_t Open(PP_Resource config_id,
  51                scoped_refptr<TrackedCallback> create_callback) override;
  52   int32_t GetSyncSocket(int* sync_socket) override;
  53   int32_t GetSharedMemory(base::SharedMemory** shm,
  54                           uint32_t* shm_size) override;
  55
  56  private:
  57   // Owning reference to the current config object. This isn't actually used,
  58   // we just dish it out as requested by the plugin.
  59   PP_Resource config_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(Audio);
  62 };
  63
  64 Audio::Audio(const HostResource& audio_id,
  65              PP_Resource config_id,
  66              const AudioCallbackCombined& callback,
  67              void* user_data)
  68     : Resource(OBJECT_IS_PROXY, audio_id),
  69       config_(config_id) {
  70   SetCallback(callback, user_data);
  71   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(config_);
  72 }
  73
  74 Audio::~Audio() {
  75 #if defined(OS_NACL)
  76   // Invoke StopPlayback() to ensure audio back-end has a chance to send the
  77   // escape value over the sync socket, which will terminate the client side
  78   // audio callback loop.  This is required for NaCl Plugins that can't escape
  79   // by shutting down the sync_socket.
  80   StopPlayback();
  81 #endif
  82   PpapiGlobals::Get()->GetResourceTracker()->ReleaseResource(config_);
  83 }
  84
  85 PPB_Audio_API* Audio::AsPPB_Audio_API() {
  86   return this;
  87 }
  88
  89 PP_Resource Audio::GetCurrentConfig() {
  90   // AddRef for the caller.
  91   PpapiGlobals::Get()->GetResourceTracker()->AddRefResource(config_);
  92   return config_;
  93 }
  94
  95 PP_Bool Audio::StartPlayback() {
  96   if (playing())
  97     return PP_TRUE;
  98   if (!PPB_Audio_Shared::IsThreadFunctionReady())
  99     return PP_FALSE;
 100   SetStartPlaybackState();
 101   PluginDispatcher::GetForResource(this)->Send(
 102       new PpapiHostMsg_PPBAudio_StartOrStop(
 103           API_ID_PPB_AUDIO, host_resource(), true));
 104   return PP_TRUE;
 105 }
 106
 107 PP_Bool Audio::StopPlayback() {
 108   if (!playing())
 109     return PP_TRUE;
 110   PluginDispatcher::GetForResource(this)->Send(
 111       new PpapiHostMsg_PPBAudio_StartOrStop(
 112           API_ID_PPB_AUDIO, host_resource(), false));
 113   SetStopPlaybackState();
 114   return PP_TRUE;
 115 }
 116
 117 int32_t Audio::Open(PP_Resource config_id,
 118                     scoped_refptr<TrackedCallback> create_callback) {
 119   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 120 }
 121
 122 int32_t Audio::GetSyncSocket(int* sync_socket) {
 123   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 124 }
 125
 126 int32_t Audio::GetSharedMemory(base::SharedMemory** shm, uint32_t* shm_size) {
 127   return PP_ERROR_NOTSUPPORTED;  // Don't proxy the trusted interface.
 128 }
 129
 130 PPB_Audio_Proxy::PPB_Audio_Proxy(Dispatcher* dispatcher)
 131     : InterfaceProxy(dispatcher),
 132       callback_factory_(this) {
 133 }
 134
 135 PPB_Audio_Proxy::~PPB_Audio_Proxy() {
 136 }
 137
 138 // static
 139 PP_Resource PPB_Audio_Proxy::CreateProxyResource(
 140     PP_Instance instance_id,
 141     PP_Resource config_id,
 142     const AudioCallbackCombined& audio_callback,
 143     void* user_data) {
 144   PluginDispatcher* dispatcher = PluginDispatcher::GetForInstance(instance_id);
 145   if (!dispatcher)
 146     return 0;
 147
 148   EnterResourceNoLock<PPB_AudioConfig_API> config(config_id, true);
 149   if (config.failed())
 150     return 0;
 151
 152   if (!audio_callback.IsValid())
 153     return 0;
 154
 155   HostResource result;
 156   dispatcher->Send(new PpapiHostMsg_PPBAudio_Create(
 157       API_ID_PPB_AUDIO, instance_id,
 158       config.object()->GetSampleRate(), config.object()->GetSampleFrameCount(),
 159       &result));
 160   if (result.is_null())
 161     return 0;
 162
 163   return (new Audio(result, config_id,
 164                     audio_callback, user_data))->GetReference();
 165 }
 166
 167 bool PPB_Audio_Proxy::OnMessageReceived(const IPC::Message& msg) {
 168   bool handled = true;
 169   IPC_BEGIN_MESSAGE_MAP(PPB_Audio_Proxy, msg)
 170 // Don't build host side into NaCl IRT.
 171 #if !defined(OS_NACL)
 172     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudio_Create, OnMsgCreate)
 173     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBAudio_StartOrStop,
 174                         OnMsgStartOrStop)
 175 #endif
 176     IPC_MESSAGE_HANDLER(PpapiMsg_PPBAudio_NotifyAudioStreamCreated,
 177                         OnMsgNotifyAudioStreamCreated)
 178     IPC_MESSAGE_UNHANDLED(handled = false)
 179   IPC_END_MESSAGE_MAP()
 180   return handled;
 181 }
 182
 183 #if !defined(OS_NACL)
 184 void PPB_Audio_Proxy::OnMsgCreate(PP_Instance instance_id,
 185                                   int32_t sample_rate,
 186                                   uint32_t sample_frame_count,
 187                                   HostResource* result) {
 188   thunk::EnterResourceCreation resource_creation(instance_id);
 189   if (resource_creation.failed())
 190     return;
 191
 192   // Make the resource and get the API pointer to its trusted interface.
 193   result->SetHostResource(
 194       instance_id,
 195       resource_creation.functions()->CreateAudioTrusted(instance_id));
 196   if (result->is_null())
 197     return;
 198
 199   // At this point, we've set the result resource, and this is a sync request.
 200   // Anything below this point must issue the AudioChannelConnected callback
 201   // to the browser. Since that's an async message, it will be issued back to
 202   // the plugin after the Create function returns (which is good because it
 203   // would be weird to get a connected message with a failure code for a
 204   // resource you haven't finished creating yet).
 205   //
 206   // The ...ForceCallback class will help ensure the callback is always called.
 207   // All error cases must call SetResult on this class.
 208   EnterHostFromHostResourceForceCallback<PPB_Audio_API> enter(
 209       *result, callback_factory_,
 210       &PPB_Audio_Proxy::AudioChannelConnected, *result);
 211   if (enter.failed())
 212     return;  // When enter fails, it will internally schedule the callback.
 213
 214   // Make an audio config object.
 215   PP_Resource audio_config_res =
 216       resource_creation.functions()->CreateAudioConfig(
 217           instance_id, static_cast<PP_AudioSampleRate>(sample_rate),
 218           sample_frame_count);
 219   if (!audio_config_res) {
 220     enter.SetResult(PP_ERROR_FAILED);
 221     return;
 222   }
 223
 224   // Initiate opening the audio object.
 225   enter.SetResult(enter.object()->Open(audio_config_res,
 226                                        enter.callback()));
 227
 228   // Clean up the temporary audio config resource we made.
 229   const PPB_Core* core = static_cast<const PPB_Core*>(
 230       dispatcher()->local_get_interface()(PPB_CORE_INTERFACE));
 231   core->ReleaseResource(audio_config_res);
 232 }
 233
 234 void PPB_Audio_Proxy::OnMsgStartOrStop(const HostResource& audio_id,
 235                                        bool play) {
 236   EnterHostFromHostResource<PPB_Audio_API> enter(audio_id);
 237   if (enter.failed())
 238     return;
 239   if (play)
 240     enter.object()->StartPlayback();
 241   else
 242     enter.object()->StopPlayback();
 243 }
 244
 245 void PPB_Audio_Proxy::AudioChannelConnected(
 246     int32_t result,
 247     const HostResource& resource) {
 248   IPC::PlatformFileForTransit socket_handle =
 249       IPC::InvalidPlatformFileForTransit();
 250   base::SharedMemoryHandle shared_memory = base::SharedMemory::NULLHandle();
 251   uint32_t audio_buffer_length = 0;
 252
 253   int32_t result_code = result;
 254   if (result_code == PP_OK) {
 255     result_code = GetAudioConnectedHandles(resource, &socket_handle,
 256                                            &shared_memory,
 257                                            &audio_buffer_length);
 258   }
 259
 260   // Send all the values, even on error. This simplifies some of our cleanup
 261   // code since the handles will be in the other process and could be
 262   // inconvenient to clean up. Our IPC code will automatically handle this for
 263   // us, as long as the remote side always closes the handles it receives
 264   // (in OnMsgNotifyAudioStreamCreated), even in the failure case.
 265   SerializedHandle fd_wrapper(SerializedHandle::SOCKET, socket_handle);
 266   SerializedHandle handle_wrapper(shared_memory, audio_buffer_length);
 267   dispatcher()->Send(new PpapiMsg_PPBAudio_NotifyAudioStreamCreated(
 268       API_ID_PPB_AUDIO, resource, result_code, fd_wrapper, handle_wrapper));
 269 }
 270
 271 int32_t PPB_Audio_Proxy::GetAudioConnectedHandles(
 272     const HostResource& resource,
 273     IPC::PlatformFileForTransit* foreign_socket_handle,
 274     base::SharedMemoryHandle* foreign_shared_memory_handle,
 275     uint32_t* shared_memory_length) {
 276   // Get the audio interface which will give us the handles.
 277   EnterHostFromHostResource<PPB_Audio_API> enter(resource);
 278   if (enter.failed())
 279     return PP_ERROR_NOINTERFACE;
 280
 281   // Get the socket handle for signaling.
 282   int32_t socket_handle;
 283   int32_t result = enter.object()->GetSyncSocket(&socket_handle);
 284   if (result != PP_OK)
 285     return result;
 286
 287   // socket_handle doesn't belong to us: don't close it.
 288   *foreign_socket_handle = dispatcher()->ShareHandleWithRemote(
 289       IntToPlatformFile(socket_handle), false);
 290   if (*foreign_socket_handle == IPC::InvalidPlatformFileForTransit())
 291     return PP_ERROR_FAILED;
 292
 293   // Get the shared memory for the buffer.
 294   base::SharedMemory* shared_memory;
 295   result =
 296       enter.object()->GetSharedMemory(&shared_memory, shared_memory_length);
 297   if (result != PP_OK)
 298     return result;
 299
 300   // shared_memory_handle doesn't belong to us: don't close it.
 301   *foreign_shared_memory_handle =
 302       dispatcher()->ShareSharedMemoryHandleWithRemote(shared_memory->handle());
 303   if (!base::SharedMemory::IsHandleValid(*foreign_shared_memory_handle))
 304     return PP_ERROR_FAILED;
 305
 306   return PP_OK;
 307 }
 308 #endif  // !defined(OS_NACL)
 309
 310 // Processed in the plugin (message from host).
 311 void PPB_Audio_Proxy::OnMsgNotifyAudioStreamCreated(
 312     const HostResource& audio_id,
 313     int32_t result_code,
 314     SerializedHandle socket_handle,
 315     SerializedHandle handle) {
 316   CHECK(socket_handle.is_socket());
 317   CHECK(handle.is_shmem());
 318   EnterPluginFromHostResource<PPB_Audio_API> enter(audio_id);
 319   if (enter.failed() || result_code != PP_OK) {
 320     // The caller may still have given us these handles in the failure case.
 321     // The easiest way to clean these up is to just put them in the objects
 322     // and then close them. This failure case is not performance critical.
 323     base::SyncSocket temp_socket(
 324         IPC::PlatformFileForTransitToPlatformFile(socket_handle.descriptor()));
 325     base::SharedMemory temp_mem(handle.shmem(), false);
 326   } else {
 327     EnterResourceNoLock<PPB_AudioConfig_API> config(
 328         static_cast<Audio*>(enter.object())->GetCurrentConfig(), true);
 329     static_cast<Audio*>(enter.object())->SetStreamInfo(
 330         enter.resource()->pp_instance(), handle.shmem(), handle.size(),
 331         IPC::PlatformFileForTransitToPlatformFile(socket_handle.descriptor()),
 332         config.object()->GetSampleRate(),
 333         config.object()->GetSampleFrameCount());
 334   }
 335 }
 336
 337 }  // namespace proxy
 338 }  // namespace ppapi