Move audio messages to their own file.

content/renderer/pepper_plugin_delegate_impl.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 "content/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "app/surface/transport_dib.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/string_split.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/common/pepper_plugin_registry.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_messages_params.h"
 #include "chrome/renderer/render_thread.h"
+#include "content/common/audio_messages.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/child_thread.h"
 #include "content/common/file_system/file_system_dispatcher.h"
 #include "content/common/pepper_file_messages.h"
 #include "content/common/pepper_messages.h"
 #include "content/renderer/audio_message_filter.h"
 #include "content/renderer/command_buffer_proxy.h"
 #include "content/renderer/content_renderer_client.h"
 #include "content/renderer/ggl.h"
 #include "content/renderer/gpu_channel_host.h"
@@ skipping 103 matching lines @@
   bool Initialize(uint32_t sample_rate, uint32_t sample_count,
        webkit::ppapi::PluginDelegate::PlatformAudio::Client* client);
 
   // PlatformAudio implementation (called on main thread).
   virtual bool StartPlayback();
   virtual bool StopPlayback();
   virtual void ShutDown();
 
  private:
   // I/O thread backends to above functions.
-  void InitializeOnIOThread(
-      const ViewHostMsg_Audio_CreateStream_Params& params);
+  void InitializeOnIOThread(const AudioParameters& params);
   void StartPlaybackOnIOThread();
   void StopPlaybackOnIOThread();
   void ShutDownOnIOThread();
 
   virtual void OnRequestPacket(AudioBuffersState buffers_state) {
     LOG(FATAL) << "Should never get OnRequestPacket in PlatformAudioImpl";
   }
 
-  virtual void OnStateChanged(const ViewMsg_AudioStreamState_Params& state) {}
+  virtual void OnStateChanged(AudioStreamState state) {}
 
   virtual void OnCreated(base::SharedMemoryHandle handle, uint32 length) {
     LOG(FATAL) << "Should never get OnCreated in PlatformAudioImpl";
   }
 
   virtual void OnLowLatencyCreated(base::SharedMemoryHandle handle,
                                    base::SyncSocket::Handle socket_handle,
                                    uint32 length);
 
   virtual void OnVolume(double volume) {}
@@ skipping 18 matching lines @@
 bool PlatformAudioImpl::Initialize(
     uint32_t sample_rate, uint32_t sample_count,
     webkit::ppapi::PluginDelegate::PlatformAudio::Client* client) {
 
   DCHECK(client);
   // Make sure we don't call init more than once.
   DCHECK_EQ(0, stream_id_);
 
   client_ = client;
 
-  ViewHostMsg_Audio_CreateStream_Params params;
-  params.params.format = AudioParameters::AUDIO_PCM_LINEAR;
-  params.params.channels = 2;
-  params.params.sample_rate = sample_rate;
-  params.params.bits_per_sample = 16;
-  params.params.samples_per_packet = sample_count;
+  AudioParameters params;
+  params.format = AudioParameters::AUDIO_PCM_LINEAR;
+  params.channels = 2;
+  params.sample_rate = sample_rate;
+  params.bits_per_sample = 16;
+  params.samples_per_packet = sample_count;
 
   filter_->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PlatformAudioImpl::InitializeOnIOThread,
                         params));
   return true;
 }
 
 bool PlatformAudioImpl::StartPlayback() {
   if (filter_) {
     filter_->message_loop()->PostTask(FROM_HERE,
@@ skipping 13 matching lines @@
 }
 
 void PlatformAudioImpl::ShutDown() {
   // Called on the main thread to stop all audio callbacks. We must only change
   // the client on the main thread, and the delegates from the I/O thread.
   client_ = NULL;
   filter_->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &PlatformAudioImpl::ShutDownOnIOThread));
 }
 
-void PlatformAudioImpl::InitializeOnIOThread(
-    const ViewHostMsg_Audio_CreateStream_Params& params) {
+void PlatformAudioImpl::InitializeOnIOThread(const AudioParameters& params) {
   stream_id_ = filter_->AddDelegate(this);
-  filter_->Send(new ViewHostMsg_CreateAudioStream(0, stream_id_, params, true));
+  filter_->Send(new AudioHostMsg_CreateStream(0, stream_id_, params, true));
 }
 
 void PlatformAudioImpl::StartPlaybackOnIOThread() {
   if (stream_id_)
-    filter_->Send(new ViewHostMsg_PlayAudioStream(0, stream_id_));
+    filter_->Send(new AudioHostMsg_PlayStream(0, stream_id_));
 }
 
 void PlatformAudioImpl::StopPlaybackOnIOThread() {
   if (stream_id_)
-    filter_->Send(new ViewHostMsg_PauseAudioStream(0, stream_id_));
+    filter_->Send(new AudioHostMsg_PauseStream(0, stream_id_));
 }
 
 void PlatformAudioImpl::ShutDownOnIOThread() {
   // Make sure we don't call shutdown more than once.
   if (!stream_id_)
     return;
 
-  filter_->Send(new ViewHostMsg_CloseAudioStream(0, stream_id_));
+  filter_->Send(new AudioHostMsg_CloseStream(0, stream_id_));
   filter_->RemoveDelegate(stream_id_);
   stream_id_ = 0;
 
   Release();  // Release for the delegate, balances out the reference taken in
               // PepperPluginDelegateImpl::CreateAudio.
 }
 
 void PlatformAudioImpl::OnLowLatencyCreated(
     base::SharedMemoryHandle handle, base::SyncSocket::Handle socket_handle,
     uint32 length) {
@@ skipping 693 matching lines @@
 }
 
 void PepperPluginDelegateImpl::HasUnsupportedFeature() {
   render_view_->Send(new ViewHostMsg_PDFHasUnsupportedFeature(
       render_view_->routing_id()));
 }
 
 P2PSocketDispatcher* PepperPluginDelegateImpl::GetP2PSocketDispatcher() {
   return render_view_->p2p_socket_dispatcher();
 }