changes for proxy audio

webkit/glue/plugins/pepper_audio.h

 // 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.
 
 #ifndef WEBKIT_GLUE_PLUGINS_PEPPER_DEVICE_CONTEXT_AUDIO_H_
 #define WEBKIT_GLUE_PLUGINS_PEPPER_DEVICE_CONTEXT_AUDIO_H_
 
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/simple_thread.h"
 #include "base/sync_socket.h"
 #include "ppapi/c/dev/ppb_audio_dev.h"
 #include "ppapi/c/dev/ppb_audio_config_dev.h"
 #include "ppapi/c/dev/ppb_audio_trusted_dev.h"
+#include "ppapi/c/pp_completion_callback.h"
 #include "webkit/glue/plugins/pepper_plugin_delegate.h"
 #include "webkit/glue/plugins/pepper_plugin_instance.h"
 #include "webkit/glue/plugins/pepper_plugin_module.h"
 #include "webkit/glue/plugins/pepper_resource.h"
 
 namespace pepper {
 
 class PluginInstance;
 class PluginModule;
 
@@ skipping 13 matching lines @@
   virtual AudioConfig* AsAudioConfig();
 
   PP_AudioSampleRate_Dev sample_rate_;
   uint32_t sample_frame_count_;
 };
 
 class Audio : public Resource,
               public PluginDelegate::PlatformAudio::Client,
               public base::DelegateSimpleThread::Delegate {
  public:
-  explicit Audio(PluginModule* module);
+  explicit Audio(PluginModule* module, PP_Instance instance_id);
   virtual ~Audio();
 
   static const PPB_Audio_Dev* GetInterface();
   static const PPB_AudioTrusted_Dev* GetTrustedInterface();
 
-  bool Init(PluginDelegate* plugin_delegate, PP_Resource config_id,
-            PPB_Audio_Callback callback, void* user_data);
+  bool Init(PluginDelegate* plugin_delegate,
+            PP_Resource config_id,
+            PPB_Audio_Callback user_callback, void* user_data);
+
+  int32_t OpenTrusted(PluginDelegate* plugin_delegate,
+                      PP_Resource config_id,
+                      PP_CompletionCallback create_callback);
+
+  void CloseTrusted();
 
   PP_Resource GetCurrentConfiguration() {
     return config_->GetReference();
   }
 
+  PP_Instance GetInstance() {

[brettw, 2010/11/22 18:22:09]

This should be called pp_instance() const {...} since it's an inline getter.

[nfullagar, 2010/11/23 02:48:58]

Done.

+    return pp_instance_;
+  }
+
+  bool GetSyncSocket(int *sync_socket);

[brettw, 2010/11/22 18:22:09]

Put the * next to the type.

[nfullagar, 2010/11/23 02:48:58]

Done.

+
+  bool GetSharedMemory(uint64_t* shm_handle, int32_t* shm_size);
+
   bool StartPlayback();
 
   bool StopPlayback();
 
   // Resource override.
   virtual Audio* AsAudio();
 
  private:
   // pepper::PluginDelegate::PlatformAudio::Client implementation.
   virtual void StreamCreated(base::SharedMemoryHandle shared_memory_handle,
                              size_t shared_memory_size_,
                              base::SyncSocket::Handle socket);
   // End of pepper::PluginDelegate::PlatformAudio::Client implementation.
 
   // Audio thread. DelegateSimpleThread::Delegate implementation.
   virtual void Run();
   // End of DelegateSimpleThread::Delegate implementation.
 
   // True if playing the stream.
   bool playing_;
 
   // AudioConfig used for creating this Audio object.
   scoped_refptr<AudioConfig> config_;
 
+  // Instance id
+  PP_Instance pp_instance_;
+
   // PluginDelegate audio object that we delegate audio IPC through.
-  scoped_ptr<PluginDelegate::PlatformAudio> audio_;
+  PluginDelegate::PlatformAudio* audio_;
 
   // Socket used to notify us when audio is ready to accept new samples. This
   // pointer is created in StreamCreated().
   scoped_ptr<base::SyncSocket> socket_;
 
   // Sample buffer in shared memory. This pointer is created in
   // StreamCreated(). The memory is only mapped when the audio thread is
   // created.
   scoped_ptr<base::SharedMemory> shared_memory_;
 
   // The size of the sample buffer in bytes.
   size_t shared_memory_size_;
 
+  // OS specific shared memory handle.
+  uint64_t shared_memory_handle_;
+
   // When the callback is set, this thread is spawned for calling it.
   scoped_ptr<base::DelegateSimpleThread> audio_thread_;
 
   // Callback to call when audio is ready to accept new samples.
   volatile PPB_Audio_Callback callback_;
 
   // User data pointer passed verbatim to the callback function.
   void* user_data_;
+
+  // Is a create callback pending to fire?
+  bool create_callback_pending_;
+
+  // Trusted callback invoked from StreamCreated.
+  PP_CompletionCallback create_callback_;
 };
 
 }  // namespace pepper
 
 #endif  // WEBKIT_GLUE_PLUGINS_PEPPER_DEVICE_CONTEXT_AUDIO_H_
-