Move audio messages to their own file.

content/browser/renderer_host/audio_renderer_host_unittest.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 "base/environment.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/sync_socket.h"
-#include "chrome/common/render_messages.h"
-#include "chrome/common/render_messages_params.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/audio_renderer_host.h"
+#include "content/common/audio_messages.h"
 #include "ipc/ipc_message_utils.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/fake_audio_output_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
@@ skipping 43 matching lines @@
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   virtual bool Send(IPC::Message* message) {
     CHECK(message);
 
     // In this method we dispatch the messages to the according handlers as if
     // we are the renderer.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(MockAudioRendererHost, *message)
-      IPC_MESSAGE_HANDLER(ViewMsg_RequestAudioPacket, OnRequestPacket)
-      IPC_MESSAGE_HANDLER(ViewMsg_NotifyAudioStreamCreated, OnStreamCreated)
-      IPC_MESSAGE_HANDLER(ViewMsg_NotifyLowLatencyAudioStreamCreated,
+      IPC_MESSAGE_HANDLER(AudioMsg_RequestPacket, OnRequestPacket)
+      IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamCreated, OnStreamCreated)
+      IPC_MESSAGE_HANDLER(AudioMsg_NotifyLowLatencyStreamCreated,
                           OnLowLatencyStreamCreated)
-      IPC_MESSAGE_HANDLER(ViewMsg_NotifyAudioStreamStateChanged,
+      IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamStateChanged,
                           OnStreamStateChanged)
-      IPC_MESSAGE_HANDLER(ViewMsg_NotifyAudioStreamVolume, OnStreamVolume)
+      IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamVolume, OnStreamVolume)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
   // These handler methods do minimal things and delegate to the mock methods.
   void OnRequestPacket(const IPC::Message& msg, int stream_id,
@@ skipping 34 matching lines @@
 #else
     sync_socket_handle = socket_descriptor.fd;
 #endif
     sync_socket_.reset(new base::SyncSocket(sync_socket_handle));
 
     // And then delegate the call to the mock method.
     OnLowLatencyStreamCreated(msg.routing_id(), stream_id, length);
   }
 
   void OnStreamStateChanged(const IPC::Message& msg, int stream_id,
-                            const ViewMsg_AudioStreamState_Params& params) {
-    if (params.state == ViewMsg_AudioStreamState_Params::kPlaying) {
+                            AudioStreamState state) {
+    if (state == kAudioStreamPlaying) {
       OnStreamPlaying(msg.routing_id(), stream_id);
-    } else if (params.state == ViewMsg_AudioStreamState_Params::kPaused) {
+    } else if (state == kAudioStreamPaused) {
       OnStreamPaused(msg.routing_id(), stream_id);
-    } else if (params.state == ViewMsg_AudioStreamState_Params::kError) {
+    } else if (state == kAudioStreamError) {
       OnStreamError(msg.routing_id(), stream_id);
     } else {
       FAIL() << "Unknown stream state";
     }
   }
 
   void OnStreamVolume(const IPC::Message& msg, int stream_id, double volume) {
     OnStreamVolume(msg.routing_id(), stream_id, volume);
   }
 
@@ skipping 45 matching lines @@
     EXPECT_CALL(*host_,
                 OnStreamCreated(kRouteId, kStreamId, _));
 
     // 2. First packet request will arrive.
     EXPECT_CALL(*host_, OnRequestPacket(kRouteId, kStreamId, _))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
     IPC::Message msg;
     msg.set_routing_id(kRouteId);
 
-    ViewHostMsg_Audio_CreateStream_Params params;
+    AudioParameters params;
     if (mock_stream_)
-      params.params.format = AudioParameters::AUDIO_MOCK;
+      params.format = AudioParameters::AUDIO_MOCK;
     else
-      params.params.format = AudioParameters::AUDIO_PCM_LINEAR;
-    params.params.channels = 2;
-    params.params.sample_rate = AudioParameters::kAudioCDSampleRate;
-    params.params.bits_per_sample = 16;
-    params.params.samples_per_packet = 0;
+      params.format = AudioParameters::AUDIO_PCM_LINEAR;
+    params.channels = 2;
+    params.sample_rate = AudioParameters::kAudioCDSampleRate;
+    params.bits_per_sample = 16;
+    params.samples_per_packet = 0;
 
     // Send a create stream message to the audio output stream and wait until
     // we receive the created message.
     host_->OnCreateStream(msg, kStreamId, params, false);
     message_loop_->Run();
   }
 
   void CreateLowLatency() {
     InSequence s;
     // We will first receive a OnLowLatencyStreamCreated() signal.
     EXPECT_CALL(*host_,
                 OnLowLatencyStreamCreated(kRouteId, kStreamId, _))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
     IPC::Message msg;
     msg.set_routing_id(kRouteId);
 
-    ViewHostMsg_Audio_CreateStream_Params params;
+    AudioParameters params;
     if (mock_stream_)
-      params.params.format = AudioParameters::AUDIO_MOCK;
+      params.format = AudioParameters::AUDIO_MOCK;
     else
-      params.params.format = AudioParameters::AUDIO_PCM_LINEAR;
-    params.params.channels = 2;
-    params.params.sample_rate = AudioParameters::kAudioCDSampleRate;
-    params.params.bits_per_sample = 16;
-    params.params.samples_per_packet = 0;
+      params.format = AudioParameters::AUDIO_PCM_LINEAR;
+    params.channels = 2;
+    params.sample_rate = AudioParameters::kAudioCDSampleRate;
+    params.bits_per_sample = 16;
+    params.samples_per_packet = 0;
 
     // Send a create stream message to the audio output stream and wait until
     // we receive the created message.
     host_->OnCreateStream(msg, kStreamId, params, true);
     message_loop_->Run();
   }
 
   void Close() {
     // Send a message to AudioRendererHost to tell it we want to close the
     // stream.
@@ skipping 225 matching lines @@
 
 // Simulate the case where a stream is not properly closed.
 TEST_F(AudioRendererHostTest, CreateLowLatencyAndShutdown) {
   if (!IsRunningHeadless())
     EnableRealDevice();
 
   CreateLowLatency();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.