Move audio messages to their own file.

content/browser/renderer_host/audio_renderer_host.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/browser/renderer_host/audio_renderer_host.h"
 
 #include "base/metrics/histogram.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
-#include "chrome/common/render_messages.h"
-#include "chrome/common/render_messages_params.h"
 #include "content/browser/renderer_host/audio_sync_reader.h"
+#include "content/common/audio_messages.h"
 #include "ipc/ipc_logging.h"
 
 namespace {
 
 // The minimum number of samples in a hardware packet.
 // This value is selected so that we can handle down to 5khz sample rate.
 const int kMinSamplesPerHardwarePacket = 1024;
 
 // The maximum number of samples in a hardware packet.
 // This value is selected so that we can handle up to 192khz sample rate.
@@ skipping 137 matching lines @@
 #endif
 
     // If we failed to prepare the sync socket for the renderer then we fail
     // the construction of audio stream.
     if (!reader->PrepareForeignSocketHandle(peer_handle(),
                                             &foreign_socket_handle)) {
       DeleteEntryOnError(entry);
       return;
     }
 
-    Send(new ViewMsg_NotifyLowLatencyAudioStreamCreated(
+    Send(new AudioMsg_NotifyLowLatencyStreamCreated(
         entry->render_view_id, entry->stream_id, foreign_memory_handle,
         foreign_socket_handle, entry->shared_memory.created_size()));
     return;
   }
 
   // The normal audio stream has created, send a message to the renderer
   // process.
-  Send(new ViewMsg_NotifyAudioStreamCreated(
+  Send(new AudioMsg_NotifyStreamCreated(
       entry->render_view_id, entry->stream_id, foreign_memory_handle,
       entry->shared_memory.created_size()));
 }
 
 void AudioRendererHost::DoSendPlayingMessage(
     media::AudioOutputController* controller) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntry* entry = LookupByController(controller);
   if (!entry)
     return;
 
-  ViewMsg_AudioStreamState_Params params;
-  params.state = ViewMsg_AudioStreamState_Params::kPlaying;
-  Send(new ViewMsg_NotifyAudioStreamStateChanged(
-      entry->render_view_id, entry->stream_id, params));
+  Send(new AudioMsg_NotifyStreamStateChanged(
+    entry->render_view_id, entry->stream_id, kAudioStreamPlaying));
 }
 
 void AudioRendererHost::DoSendPausedMessage(
     media::AudioOutputController* controller) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntry* entry = LookupByController(controller);
   if (!entry)
     return;
 
-  ViewMsg_AudioStreamState_Params params;
-  params.state = ViewMsg_AudioStreamState_Params::kPaused;
-  Send(new ViewMsg_NotifyAudioStreamStateChanged(
-      entry->render_view_id, entry->stream_id, params));
+  Send(new AudioMsg_NotifyStreamStateChanged(
+      entry->render_view_id, entry->stream_id, kAudioStreamPaused));
 }
 
 void AudioRendererHost::DoRequestMoreData(
     media::AudioOutputController* controller,
     AudioBuffersState buffers_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // If we already have a pending request then return.
   AudioEntry* entry = LookupByController(controller);
   if (!entry || entry->pending_buffer_request)
     return;
 
   DCHECK(!entry->controller->LowLatencyMode());
   entry->pending_buffer_request = true;
-  Send(new ViewMsg_RequestAudioPacket(
+  Send(new AudioMsg_RequestPacket(
       entry->render_view_id, entry->stream_id, buffers_state));
 }
 
 void AudioRendererHost::DoHandleError(media::AudioOutputController* controller,
                                       int error_code) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   AudioEntry* entry = LookupByController(controller);
   if (!entry)
     return;
 
   DeleteEntryOnError(entry);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // IPC Messages handler
 bool AudioRendererHost::OnMessageReceived(const IPC::Message& message,
                                           bool* message_was_ok) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(AudioRendererHost, message, *message_was_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_CreateAudioStream, OnCreateStream)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_PlayAudioStream, OnPlayStream)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_PauseAudioStream, OnPauseStream)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_FlushAudioStream, OnFlushStream)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_CloseAudioStream, OnCloseStream)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_NotifyAudioPacketReady, OnNotifyPacketReady)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioVolume, OnGetVolume)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_SetAudioVolume, OnSetVolume)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_CreateStream, OnCreateStream)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_PlayStream, OnPlayStream)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_PauseStream, OnPauseStream)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_FlushStream, OnFlushStream)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_CloseStream, OnCloseStream)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_NotifyPacketReady, OnNotifyPacketReady)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_GetVolume, OnGetVolume)
+    IPC_MESSAGE_HANDLER(AudioHostMsg_SetVolume, OnSetVolume)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
 
   return handled;
 }
 
 void AudioRendererHost::OnCreateStream(
     const IPC::Message& msg, int stream_id,
-    const ViewHostMsg_Audio_CreateStream_Params& params, bool low_latency) {
+    const AudioParameters& params, bool low_latency) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(LookupById(msg.routing_id(), stream_id) == NULL);
 
-  AudioParameters audio_params(params.params);
+  AudioParameters audio_params(params);
 
   // Select the hardware packet size if not specified.
   if (!audio_params.samples_per_packet) {
     audio_params.samples_per_packet = SelectSamplesPerPacket(audio_params);
   }
   uint32 packet_size = audio_params.GetPacketSize();
 
   scoped_ptr<AudioEntry> entry(new AudioEntry());
   // Create the shared memory and share with the renderer process.
   if (!entry->shared_memory.CreateAndMapAnonymous(packet_size)) {
@@ skipping 126 matching lines @@
   entry->pending_buffer_request = false;
 
   // Enqueue the data to media::AudioOutputController.
   entry->controller->EnqueueData(
       reinterpret_cast<uint8*>(entry->shared_memory.memory()),
       packet_size);
 }
 
 void AudioRendererHost::SendErrorMessage(int32 render_view_id,
                                          int32 stream_id) {
-  ViewMsg_AudioStreamState_Params state;
-  state.state = ViewMsg_AudioStreamState_Params::kError;
-  Send(new ViewMsg_NotifyAudioStreamStateChanged(
-      render_view_id, stream_id, state));
+  Send(new AudioMsg_NotifyStreamStateChanged(
+      render_view_id, stream_id, kAudioStreamError));
 }
 
 void AudioRendererHost::DeleteEntries() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (AudioEntryMap::iterator i = audio_entries_.begin();
        i != audio_entries_.end(); ++i) {
     CloseAndDeleteStream(i->second);
   }
 }
@@ skipping 50 matching lines @@
 
   // Iterate the map of entries.
   // TODO(hclam): Implement a faster look up method.
   for (AudioEntryMap::iterator i = audio_entries_.begin();
        i != audio_entries_.end(); ++i) {
     if (!i->second->pending_close && controller == i->second->controller.get())
       return i->second;
   }
   return NULL;
 }