Implements AudioMessageFilter as member in RenderThread

content/browser/renderer_host/media/audio_renderer_host_unittest.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 "base/environment.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/sync_socket.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/media/audio_renderer_host.h"
 #include "content/common/media/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;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::SetArgumentPointee;
 
-static const int kInvalidId = -1;
-static const int kRouteId = 200;
 static const int kStreamId = 50;
 
 static bool IsRunningHeadless() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->HasVar("CHROME_HEADLESS"))
     return true;
   return false;
 }
 
 class MockAudioRendererHost : public AudioRendererHost {
  public:
   MockAudioRendererHost() : shared_memory_length_(0) {
   }
 
   virtual ~MockAudioRendererHost() {
   }
 
   // A list of mock methods.
-  MOCK_METHOD3(OnRequestPacket,
-               void(int routing_id, int stream_id,
-                    AudioBuffersState buffers_state));
-  MOCK_METHOD3(OnStreamCreated,
-               void(int routing_id, int stream_id, int length));
-  MOCK_METHOD3(OnLowLatencyStreamCreated,
-               void(int routing_id, int stream_id, int length));
-  MOCK_METHOD2(OnStreamPlaying, void(int routing_id, int stream_id));
-  MOCK_METHOD2(OnStreamPaused, void(int routing_id, int stream_id));
-  MOCK_METHOD2(OnStreamError, void(int routing_id, int stream_id));
-  MOCK_METHOD3(OnStreamVolume,
-               void(int routing_id, int stream_id, double volume));
+  MOCK_METHOD2(OnRequestPacket,
+               void(int stream_id, AudioBuffersState buffers_state));
+  MOCK_METHOD2(OnStreamCreated,
+               void(int stream_id, int length));
+  MOCK_METHOD2(OnLowLatencyStreamCreated,
+               void(int stream_id, int length));
+  MOCK_METHOD1(OnStreamPlaying, void(int stream_id));
+  MOCK_METHOD1(OnStreamPaused, void(int stream_id));
+  MOCK_METHOD1(OnStreamError, void(int stream_id));
+  MOCK_METHOD2(OnStreamVolume,
+               void(int stream_id, double volume));
 
   base::SharedMemory* shared_memory() { return shared_memory_.get(); }
   uint32 shared_memory_length() { return shared_memory_length_; }
 
   base::SyncSocket* sync_socket() { return sync_socket_.get(); }
 
  private:
   // 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.
@@ skipping 15 matching lines @@
     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,
                        AudioBuffersState buffers_state) {
-    OnRequestPacket(msg.routing_id(), stream_id, buffers_state);
+    OnRequestPacket(stream_id, buffers_state);
   }
 
   void OnStreamCreated(const IPC::Message& msg, int stream_id,
                        base::SharedMemoryHandle handle, uint32 length) {
     // Maps the shared memory.
     shared_memory_.reset(new base::SharedMemory(handle, false));
     ASSERT_TRUE(shared_memory_->Map(length));
     ASSERT_TRUE(shared_memory_->memory());
     shared_memory_length_ = length;
 
     // And then delegate the call to the mock method.
-    OnStreamCreated(msg.routing_id(), stream_id, length);
+    OnStreamCreated(stream_id, length);
   }
 
   void OnLowLatencyStreamCreated(const IPC::Message& msg, int stream_id,
                                base::SharedMemoryHandle handle,
 #if defined(OS_WIN)
                                base::SyncSocket::Handle socket_handle,
 #else
                                base::FileDescriptor socket_descriptor,
 #endif
                                uint32 length) {
     // Maps the shared memory.
     shared_memory_.reset(new base::SharedMemory(handle, false));
     CHECK(shared_memory_->Map(length));
     CHECK(shared_memory_->memory());
     shared_memory_length_ = length;
 
     // Create the SyncSocket using the handle.
     base::SyncSocket::Handle sync_socket_handle;
 #if defined(OS_WIN)
     sync_socket_handle = socket_handle;
 #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);
+    OnLowLatencyStreamCreated(stream_id, length);
   }
 
   void OnStreamStateChanged(const IPC::Message& msg, int stream_id,
                             AudioStreamState state) {
     if (state == kAudioStreamPlaying) {
-      OnStreamPlaying(msg.routing_id(), stream_id);
+      OnStreamPlaying(stream_id);
     } else if (state == kAudioStreamPaused) {
-      OnStreamPaused(msg.routing_id(), stream_id);
+      OnStreamPaused(stream_id);
     } else if (state == kAudioStreamError) {
-      OnStreamError(msg.routing_id(), stream_id);
+      OnStreamError(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);
+    OnStreamVolume(stream_id, volume);
   }
 
   scoped_ptr<base::SharedMemory> shared_memory_;
   scoped_ptr<base::SyncSocket> sync_socket_;
   uint32 shared_memory_length_;
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioRendererHost);
 };
 
 ACTION_P(QuitMessageLoop, message_loop) {
@@ skipping 28 matching lines @@
     // We need to continue running message_loop_ to complete all destructions.
     SyncWithAudioThread();
 
     io_thread_.reset();
   }
 
   void Create() {
     InSequence s;
     // 1. We will first receive a OnStreamCreated() signal.
     EXPECT_CALL(*host_,
-                OnStreamCreated(kRouteId, kStreamId, _));
+                OnStreamCreated(kStreamId, _));
 
     // 2. First packet request will arrive.
-    EXPECT_CALL(*host_, OnRequestPacket(kRouteId, kStreamId, _))
+    EXPECT_CALL(*host_, OnRequestPacket(kStreamId, _))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-
     AudioParameters params;
     if (mock_stream_)
       params.format = AudioParameters::AUDIO_MOCK;
     else
       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);
+    host_->OnCreateStream(kStreamId, params, false);
     message_loop_->Run();
   }
 
   void CreateLowLatency() {
     InSequence s;
     // We will first receive a OnLowLatencyStreamCreated() signal.
     EXPECT_CALL(*host_,
-                OnLowLatencyStreamCreated(kRouteId, kStreamId, _))
+                OnLowLatencyStreamCreated(kStreamId, _))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-
     AudioParameters params;
     if (mock_stream_)
       params.format = AudioParameters::AUDIO_MOCK;
     else
       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);
+    host_->OnCreateStream(kStreamId, params, true);
     message_loop_->Run();
   }
 
   void Close() {
     // Send a message to AudioRendererHost to tell it we want to close the
     // stream.
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-    host_->OnCloseStream(msg, kStreamId);
+    host_->OnCloseStream(kStreamId);
     message_loop_->RunAllPending();
   }
 
   void Play() {
-    EXPECT_CALL(*host_, OnStreamPlaying(kRouteId, kStreamId))
+    EXPECT_CALL(*host_, OnStreamPlaying(kStreamId))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-    host_->OnPlayStream(msg, kStreamId);
+    host_->OnPlayStream(kStreamId);
     message_loop_->Run();
   }
 
   void Pause() {
-    EXPECT_CALL(*host_, OnStreamPaused(kRouteId, kStreamId))
+    EXPECT_CALL(*host_, OnStreamPaused(kStreamId))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-    host_->OnPauseStream(msg, kStreamId);
+    host_->OnPauseStream(kStreamId);
     message_loop_->Run();
   }
 
   void SetVolume(double volume) {
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
-    host_->OnSetVolume(msg, kStreamId, volume);
+    host_->OnSetVolume(kStreamId, volume);
     message_loop_->RunAllPending();
   }
 
   void NotifyPacketReady() {
-    EXPECT_CALL(*host_, OnRequestPacket(kRouteId, kStreamId, _))
+    EXPECT_CALL(*host_, OnRequestPacket(kStreamId, _))
         .WillOnce(QuitMessageLoop(message_loop_.get()));
 
-    IPC::Message msg;
-    msg.set_routing_id(kRouteId);
     memset(host_->shared_memory()->memory(), 0, host_->shared_memory_length());
-    host_->OnNotifyPacketReady(msg, kStreamId,
-                               host_->shared_memory_length());
+    host_->OnNotifyPacketReady(kStreamId, host_->shared_memory_length());
     message_loop_->Run();
   }
 
   void SimulateError() {
     // Find the first AudioOutputController in the AudioRendererHost.
     CHECK(host_->audio_entries_.size())
         << "Calls Create() before calling this method";
     media::AudioOutputController* controller =
         host_->audio_entries_.begin()->second->controller;
     CHECK(controller) << "AudioOutputController not found";
 
     // Expect an error signal sent through IPC.
-    EXPECT_CALL(*host_, OnStreamError(kRouteId, kStreamId));
+    EXPECT_CALL(*host_, OnStreamError(kStreamId));
 
     // Simulate an error sent from the audio device.
     host_->OnError(controller, 0);
     SyncWithAudioThread();
 
     // Expect the audio stream record is removed.
     EXPECT_EQ(0u, host_->audio_entries_.size());
   }
 
   // Called on the audio thread.
@@ skipping 160 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.