changes for proxy audio

webkit/glue/plugins/pepper_audio.cc

 // Copyright (c) 2010 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 "webkit/glue/plugins/pepper_audio.h"
 
 #include "base/logging.h"
-#include "ppapi/c/dev/ppb_audio_dev.h"
-#include "ppapi/c/dev/ppb_audio_trusted_dev.h"
+#include "third_party/ppapi/c/dev/ppb_audio_dev.h"
+#include "third_party/ppapi/c/dev/ppb_audio_trusted_dev.h"
 #include "webkit/glue/plugins/pepper_common.h"
 
 namespace pepper {
 
 namespace {
 
 // PPB_AudioConfig -------------------------------------------------------------
 
 uint32_t RecommendSampleFrameCount(uint32_t requested_sample_frame_count);
 
@@ skipping 50 matching lines @@
   &CreateStereo16bit,
   &RecommendSampleFrameCount,
   &IsAudioConfig,
   &GetSampleRate,
   &GetSampleFrameCount
 };
 
 // PPB_Audio -------------------------------------------------------------------
 
 PP_Resource Create(PP_Instance instance_id, PP_Resource config_id,
-                   PPB_Audio_Callback callback, void* user_data) {
+                   PPB_Audio_Callback user_callback, void* user_data) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return 0;
   // TODO(neb): Require callback to be present for untrusted plugins.
   scoped_refptr<Audio> audio(new Audio(instance->module()));
-  if (!audio->Init(instance->delegate(), config_id, callback, user_data))
+  if (!audio->Init(instance->delegate(), instance_id, config_id,
+      user_callback, user_data, NULL))
     return 0;
   return audio->GetReference();
 }
 
 PP_Bool IsAudio(PP_Resource resource) {
   scoped_refptr<Audio> audio = Resource::GetAs<Audio>(resource);
   return BoolToPPBool(!!audio);
 }
 
 PP_Resource GetCurrentConfiguration(PP_Resource audio_id) {
@@ skipping 14 matching lines @@
 const PPB_Audio_Dev ppb_audio = {
   &Create,
   &IsAudio,
   &GetCurrentConfiguration,
   &StartPlayback,
   &StopPlayback,
 };
 
 // PPB_AudioTrusted ------------------------------------------------------------
 
-PP_Resource GetBuffer(PP_Resource audio_id) {
-  // TODO(neb): Implement me!
-  return 0;
-}
-
-int GetOSDescriptor(PP_Resource audio_id) {
-  // TODO(neb): Implement me!
-  return -1;
+PP_Resource CreateTrusted(PP_Instance instance_id, PP_Resource config_id,
+                          PPB_AudioTrusted_Callback created) {
+  PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
+  if (!instance)
+    return 0;
+  scoped_refptr<Audio> audio(new Audio(instance->module()));
+  if (!audio->Init(instance->delegate(), instance_id, config_id,
+      NULL, NULL, created))

[darin (slow to review), 2010/11/19 17:45:39]

nit: please indent so the start of the arguments are aligned

+    return 0;
+  return audio->GetReference();
 }
 
 const PPB_AudioTrusted_Dev ppb_audiotrusted = {
-  &GetBuffer,
-  &GetOSDescriptor
+  &CreateTrusted
 };
 
 }  // namespace
 
 // AudioConfig -----------------------------------------------------------------
 
 AudioConfig::AudioConfig(PluginModule* module,
                          PP_AudioSampleRate_Dev sample_rate,
                          uint32_t sample_frame_count)
     : Resource(module),
@@ skipping 17 matching lines @@
 
 AudioConfig* AudioConfig::AsAudioConfig() {
   return this;
 }
 
 // Audio -----------------------------------------------------------------------
 
 Audio::Audio(PluginModule* module)
     : Resource(module),
       playing_(false),
+      pp_instance_(0),
+      audio_(NULL),
       socket_(NULL),
       shared_memory_(NULL),
       shared_memory_size_(0),
       callback_(NULL),
-      user_data_(NULL) {
+      user_data_(NULL),
+      create_callback_(NULL) {
 }
 
 Audio::~Audio() {
   // Calling ShutDown() makes sure StreamCreated cannot be called anymore.
   audio_->ShutDown();
+  audio_ = NULL;
   // Closing the socket causes the thread to exit - wait for it.
   socket_->Close();
   if (audio_thread_.get()) {
     audio_thread_->Join();
     audio_thread_.reset();
   }
   // Shared memory destructor will unmap the memory automatically.
 }
 
 const PPB_Audio_Dev* Audio::GetInterface() {
   return &ppb_audio;
 }
 
 const PPB_AudioTrusted_Dev* Audio::GetTrustedInterface() {
   return &ppb_audiotrusted;
 }
 
 Audio* Audio::AsAudio() {
   return this;
 }
 
-bool Audio::Init(PluginDelegate* plugin_delegate, PP_Resource config_id,
-                 PPB_Audio_Callback callback, void* user_data) {
-  CHECK(!audio_.get());
+bool Audio::Init(PluginDelegate* plugin_delegate,
+                 PP_Instance instance_id,
+                 PP_Resource config_id,
+                 PPB_Audio_Callback callback, void* user_data,
+                 PPB_AudioTrusted_Callback create_callback) {
+  CHECK(!audio_);
   config_ = Resource::GetAs<AudioConfig>(config_id);
   if (!config_)
     return false;
+  pp_instance_ = instance_id;
   callback_ = callback;
   user_data_ = user_data;
-  // When the stream is created, we'll get called back in StreamCreated().
-  audio_.reset(plugin_delegate->CreateAudio(config_->sample_rate(),
-                                            config_->sample_frame_count(),
-                                            this));
-  return audio_.get() != NULL;
+  create_callback_ = create_callback;
+  // When the stream is created, we'll get called back on StreamCreated().
+  audio_ = plugin_delegate->CreateAudio(config_->sample_rate(),
+                                        config_->sample_frame_count(),
+                                        this);
+  return audio_ != NULL;
 }
 
 bool Audio::StartPlayback() {
   if (playing_)
     return true;
 
   CHECK(!audio_thread_.get());
   if (callback_ && socket_.get()) {
     audio_thread_.reset(new base::DelegateSimpleThread(this,
                                                        "plugin_audio_thread"));
@@ skipping 17 matching lines @@
   playing_ = false;
   return true;
 }
 
 void Audio::StreamCreated(base::SharedMemoryHandle shared_memory_handle,
                           size_t shared_memory_size,
                           base::SyncSocket::Handle socket_handle) {
   socket_.reset(new base::SyncSocket(socket_handle));
   shared_memory_.reset(new base::SharedMemory(shared_memory_handle, false));
   shared_memory_size_ = shared_memory_size;
-
+  // Trusted side of proxy can specify a callback to recieve handles on.
+  if (create_callback_) {
+#if OS_LINUX || OS_MAC
+    int64_t shm_handle = static_cast<int64_t>(shared_memory_handle.fd);
+#elif OS_WIN
+    int64_T shm_handle = static_cast<int64_t>(shared_memory_handle);
+#else
+  #error "Unknown OS"

[darin (slow to review), 2010/11/19 17:45:39]

nit: indent by 4 spaces like the other branches?

+#endif
+    create_callback_(pp_instance_, GetReference(), shm_handle,
+        shared_memory_size, static_cast<int64_t>(socket_handle));

[darin (slow to review), 2010/11/19 17:45:39]

nit: align the arguments so they all start at the same column

+  }
+  // Recurring callback to fill audio buffers.
   if (callback_) {
     shared_memory_->Map(shared_memory_size_);
     // In common case StartPlayback() was called before StreamCreated().
     if (playing_) {
       audio_thread_.reset(new base::DelegateSimpleThread(this,
           "plugin_audio_thread"));
       audio_thread_->Start();
     }
   }
 }
 
 void Audio::Run() {
   int pending_data;
   void* buffer = shared_memory_->memory();
   size_t buffer_size_in_bytes = config_->BufferSize();
 
   while (sizeof(pending_data) ==
       socket_->Receive(&pending_data, sizeof(pending_data)) &&
       pending_data >= 0) {
     // Exit the thread on pause.
     if (pending_data < 0)
       return;
     callback_(buffer, buffer_size_in_bytes, user_data_);
   }
 }
 
 }  // namespace pepper