1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #include "content/test/webrtc_audio_device_test.h"
8 #include "base/bind_helpers.h"
9 #include "base/compiler_specific.h"
10 #include "base/file_util.h"
11 #include "base/message_loop/message_loop.h"
12 #include "base/run_loop.h"
13 #include "base/synchronization/waitable_event.h"
14 #include "base/test/test_timeouts.h"
15 #include "content/browser/renderer_host/media/audio_input_renderer_host.h"
16 #include "content/browser/renderer_host/media/audio_mirroring_manager.h"
17 #include "content/browser/renderer_host/media/audio_renderer_host.h"
18 #include "content/browser/renderer_host/media/media_stream_manager.h"
19 #include "content/browser/renderer_host/media/mock_media_observer.h"
20 #include "content/common/media/media_param_traits.h"
21 #include "content/common/view_messages.h"
22 #include "content/public/browser/browser_thread.h"
23 #include "content/public/common/content_paths.h"
24 #include "content/public/test/mock_resource_context.h"
25 #include "content/public/test/test_browser_thread.h"
26 #include "content/renderer/media/audio_input_message_filter.h"
27 #include "content/renderer/media/audio_message_filter.h"
28 #include "content/renderer/media/webrtc_audio_device_impl.h"
29 #include "content/renderer/render_process.h"
30 #include "content/renderer/render_thread_impl.h"
31 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
32 #include "media/audio/audio_parameters.h"
33 #include "media/base/audio_hardware_config.h"
34 #include "net/url_request/url_request_test_util.h"
35 #include "testing/gmock/include/gmock/gmock.h"
36 #include "testing/gtest/include/gtest/gtest.h"
37 #include "third_party/webrtc/voice_engine/include/voe_audio_processing.h"
38 #include "third_party/webrtc/voice_engine/include/voe_base.h"
39 #include "third_party/webrtc/voice_engine/include/voe_file.h"
40 #include "third_party/webrtc/voice_engine/include/voe_network.h"
43 #include "base/win/scoped_com_initializer.h"
46 using media::AudioParameters
;
47 using media::ChannelLayout
;
49 using testing::InvokeWithoutArgs
;
50 using testing::Return
;
55 // This class is a mock of the child process singleton which is needed
56 // to be able to create a RenderThread object.
57 class WebRTCMockRenderProcess
: public RenderProcess
{
59 WebRTCMockRenderProcess() {}
60 virtual ~WebRTCMockRenderProcess() {}
62 // RenderProcess implementation.
63 virtual skia::PlatformCanvas
* GetDrawingCanvas(
64 TransportDIB
** memory
, const gfx::Rect
& rect
) OVERRIDE
{
67 virtual void ReleaseTransportDIB(TransportDIB
* memory
) OVERRIDE
{}
68 virtual bool UseInProcessPlugins() const OVERRIDE
{ return false; }
69 virtual void AddBindings(int bindings
) OVERRIDE
{}
70 virtual int GetEnabledBindings() const OVERRIDE
{ return 0; }
71 virtual TransportDIB
* CreateTransportDIB(size_t size
) OVERRIDE
{
74 virtual void FreeTransportDIB(TransportDIB
*) OVERRIDE
{}
77 DISALLOW_COPY_AND_ASSIGN(WebRTCMockRenderProcess
);
80 // Utility scoped class to replace the global content client's renderer for the
81 // duration of the test.
82 class ReplaceContentClientRenderer
{
84 explicit ReplaceContentClientRenderer(ContentRendererClient
* new_renderer
) {
85 saved_renderer_
= SetRendererClientForTesting(new_renderer
);
87 ~ReplaceContentClientRenderer() {
88 // Restore the original renderer.
89 SetRendererClientForTesting(saved_renderer_
);
92 ContentRendererClient
* saved_renderer_
;
93 DISALLOW_COPY_AND_ASSIGN(ReplaceContentClientRenderer
);
96 class MockRTCResourceContext
: public ResourceContext
{
98 MockRTCResourceContext() : test_request_context_(NULL
) {}
99 virtual ~MockRTCResourceContext() {}
101 void set_request_context(net::URLRequestContext
* request_context
) {
102 test_request_context_
= request_context
;
105 // ResourceContext implementation:
106 virtual net::HostResolver
* GetHostResolver() OVERRIDE
{
109 virtual net::URLRequestContext
* GetRequestContext() OVERRIDE
{
110 return test_request_context_
;
114 net::URLRequestContext
* test_request_context_
;
116 DISALLOW_COPY_AND_ASSIGN(MockRTCResourceContext
);
119 ACTION_P(QuitMessageLoop
, loop_or_proxy
) {
120 loop_or_proxy
->PostTask(FROM_HERE
, base::MessageLoop::QuitClosure());
123 WebRTCAudioDeviceTest::WebRTCAudioDeviceTest()
124 : render_thread_(NULL
), audio_hardware_config_(NULL
),
125 has_input_devices_(false), has_output_devices_(false) {
128 WebRTCAudioDeviceTest::~WebRTCAudioDeviceTest() {}
130 void WebRTCAudioDeviceTest::SetUp() {
131 // This part sets up a RenderThread environment to ensure that
132 // RenderThread::current() (<=> TLS pointer) is valid.
133 // Main parts are inspired by the RenderViewFakeResourcesTest.
134 // Note that, the IPC part is not utilized in this test.
135 saved_content_renderer_
.reset(
136 new ReplaceContentClientRenderer(&content_renderer_client_
));
137 mock_process_
.reset(new WebRTCMockRenderProcess());
139 new TestBrowserThread(BrowserThread::UI
, base::MessageLoop::current()));
141 // Construct the resource context on the UI thread.
142 resource_context_
.reset(new MockRTCResourceContext
);
144 static const char kThreadName
[] = "RenderThread";
145 ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE
,
146 base::Bind(&WebRTCAudioDeviceTest::InitializeIOThread
,
147 base::Unretained(this), kThreadName
));
148 WaitForIOThreadCompletion();
150 sandbox_was_enabled_
=
151 RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(false);
152 render_thread_
= new RenderThreadImpl(kThreadName
);
155 void WebRTCAudioDeviceTest::TearDown() {
156 SetAudioHardwareConfig(NULL
);
158 // Run any pending cleanup tasks that may have been posted to the main thread.
159 base::RunLoop().RunUntilIdle();
161 // Kick of the cleanup process by closing the channel. This queues up
162 // OnStreamClosed calls to be executed on the audio thread.
163 ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE
,
164 base::Bind(&WebRTCAudioDeviceTest::DestroyChannel
,
165 base::Unretained(this)));
166 WaitForIOThreadCompletion();
168 // When audio [input] render hosts are notified that the channel has
169 // been closed, they post tasks to the audio thread to close the
170 // AudioOutputController and once that's completed, a task is posted back to
171 // the IO thread to actually delete the AudioEntry for the audio stream. Only
172 // then is the reference to the audio manager released, so we wait for the
173 // whole thing to be torn down before we finally uninitialize the io thread.
174 WaitForAudioManagerCompletion();
176 ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE
,
177 base::Bind(&WebRTCAudioDeviceTest::UninitializeIOThread
,
178 base::Unretained((this))));
179 WaitForIOThreadCompletion();
180 mock_process_
.reset();
181 media_stream_manager_
.reset();
182 mirroring_manager_
.reset();
183 RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(
184 sandbox_was_enabled_
);
187 bool WebRTCAudioDeviceTest::Send(IPC::Message
* message
) {
188 return channel_
->Send(message
);
191 void WebRTCAudioDeviceTest::SetAudioHardwareConfig(
192 media::AudioHardwareConfig
* hardware_config
) {
193 audio_hardware_config_
= hardware_config
;
196 void WebRTCAudioDeviceTest::InitializeIOThread(const char* thread_name
) {
198 // We initialize COM (STA) on our IO thread as is done in Chrome.
199 // See BrowserProcessSubThread::Init.
200 initialize_com_
.reset(new base::win::ScopedCOMInitializer());
203 // Set the current thread as the IO thread.
205 new TestBrowserThread(BrowserThread::IO
, base::MessageLoop::current()));
207 // Populate our resource context.
208 test_request_context_
.reset(new net::TestURLRequestContext());
209 MockRTCResourceContext
* resource_context
=
210 static_cast<MockRTCResourceContext
*>(resource_context_
.get());
211 resource_context
->set_request_context(test_request_context_
.get());
212 media_internals_
.reset(new MockMediaInternals());
214 // Create our own AudioManager, AudioMirroringManager and MediaStreamManager.
215 audio_manager_
.reset(media::AudioManager::Create());
216 mirroring_manager_
.reset(new AudioMirroringManager());
217 media_stream_manager_
.reset(new MediaStreamManager(audio_manager_
.get()));
219 has_input_devices_
= audio_manager_
->HasAudioInputDevices();
220 has_output_devices_
= audio_manager_
->HasAudioOutputDevices();
222 // Create an IPC channel that handles incoming messages on the IO thread.
223 CreateChannel(thread_name
);
226 void WebRTCAudioDeviceTest::UninitializeIOThread() {
227 resource_context_
.reset();
229 test_request_context_
.reset();
232 initialize_com_
.reset();
235 audio_manager_
.reset();
238 void WebRTCAudioDeviceTest::CreateChannel(const char* name
) {
239 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO
));
241 static const int kRenderProcessId
= 1;
242 audio_render_host_
= new AudioRendererHost(
243 kRenderProcessId
, audio_manager_
.get(), mirroring_manager_
.get(),
244 media_internals_
.get(), media_stream_manager_
.get());
245 audio_render_host_
->OnChannelConnected(base::GetCurrentProcId());
247 audio_input_renderer_host_
= new AudioInputRendererHost(
248 audio_manager_
.get(), media_stream_manager_
.get(),
249 mirroring_manager_
.get());
250 audio_input_renderer_host_
->OnChannelConnected(base::GetCurrentProcId());
252 channel_
.reset(new IPC::Channel(name
, IPC::Channel::MODE_SERVER
, this));
253 ASSERT_TRUE(channel_
->Connect());
255 audio_render_host_
->OnFilterAdded(channel_
.get());
256 audio_input_renderer_host_
->OnFilterAdded(channel_
.get());
259 void WebRTCAudioDeviceTest::DestroyChannel() {
260 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO
));
261 audio_render_host_
->OnChannelClosing();
262 audio_render_host_
->OnFilterRemoved();
263 audio_input_renderer_host_
->OnChannelClosing();
264 audio_input_renderer_host_
->OnFilterRemoved();
266 audio_render_host_
= NULL
;
267 audio_input_renderer_host_
= NULL
;
270 void WebRTCAudioDeviceTest::OnGetAudioHardwareConfig(
271 AudioParameters
* input_params
, AudioParameters
* output_params
) {
272 ASSERT_TRUE(audio_hardware_config_
);
273 *input_params
= audio_hardware_config_
->GetInputConfig();
274 *output_params
= audio_hardware_config_
->GetOutputConfig();
277 // IPC::Listener implementation.
278 bool WebRTCAudioDeviceTest::OnMessageReceived(const IPC::Message
& message
) {
279 if (render_thread_
) {
280 IPC::ChannelProxy::MessageFilter
* filter
=
281 render_thread_
->audio_input_message_filter();
282 if (filter
->OnMessageReceived(message
))
285 filter
= render_thread_
->audio_message_filter();
286 if (filter
->OnMessageReceived(message
))
290 if (audio_render_host_
.get()) {
291 bool message_was_ok
= false;
292 if (audio_render_host_
->OnMessageReceived(message
, &message_was_ok
))
296 if (audio_input_renderer_host_
.get()) {
297 bool message_was_ok
= false;
298 if (audio_input_renderer_host_
->OnMessageReceived(message
, &message_was_ok
))
302 bool handled ALLOW_UNUSED
= true;
303 bool message_is_ok
= true;
304 IPC_BEGIN_MESSAGE_MAP_EX(WebRTCAudioDeviceTest
, message
, message_is_ok
)
305 IPC_MESSAGE_HANDLER(ViewHostMsg_GetAudioHardwareConfig
,
306 OnGetAudioHardwareConfig
)
307 IPC_MESSAGE_UNHANDLED(handled
= false)
308 IPC_END_MESSAGE_MAP_EX()
310 EXPECT_TRUE(message_is_ok
);
315 // Posts a final task to the IO message loop and waits for completion.
316 void WebRTCAudioDeviceTest::WaitForIOThreadCompletion() {
317 WaitForMessageLoopCompletion(
318 ChildProcess::current()->io_message_loop()->message_loop_proxy().get());
321 void WebRTCAudioDeviceTest::WaitForAudioManagerCompletion() {
323 WaitForMessageLoopCompletion(audio_manager_
->GetMessageLoop().get());
326 void WebRTCAudioDeviceTest::WaitForMessageLoopCompletion(
327 base::MessageLoopProxy
* loop
) {
328 base::WaitableEvent
* event
= new base::WaitableEvent(false, false);
329 loop
->PostTask(FROM_HERE
, base::Bind(&base::WaitableEvent::Signal
,
330 base::Unretained(event
)));
331 if (event
->TimedWait(TestTimeouts::action_max_timeout())) {
334 // Don't delete the event object in case the message ever gets processed.
335 // If we do, we will crash the test process.
336 ADD_FAILURE() << "Failed to wait for message loop";
340 std::string
WebRTCAudioDeviceTest::GetTestDataPath(
341 const base::FilePath::StringType
& file_name
) {
343 EXPECT_TRUE(PathService::Get(DIR_TEST_DATA
, &path
));
344 path
= path
.Append(file_name
);
345 EXPECT_TRUE(base::PathExists(path
));
347 return WideToUTF8(path
.value());
353 WebRTCTransportImpl::WebRTCTransportImpl(webrtc::VoENetwork
* network
)
354 : network_(network
) {
357 WebRTCTransportImpl::~WebRTCTransportImpl() {}
359 int WebRTCTransportImpl::SendPacket(int channel
, const void* data
, int len
) {
360 return network_
->ReceivedRTPPacket(channel
, data
, len
);
363 int WebRTCTransportImpl::SendRTCPPacket(int channel
, const void* data
,
365 return network_
->ReceivedRTCPPacket(channel
, data
, len
);
368 } // namespace content