1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
|
// Copyright (c) 2012 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/test/webrtc_audio_device_test.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/compiler_specific.h"
#include "base/file_util.h"
#include "base/message_loop.h"
#include "base/synchronization/waitable_event.h"
#include "base/test/test_timeouts.h"
#include "content/browser/renderer_host/media/audio_input_renderer_host.h"
#include "content/browser/renderer_host/media/audio_renderer_host.h"
#include "content/browser/renderer_host/media/media_stream_manager.h"
#include "content/browser/renderer_host/media/mock_media_observer.h"
#include "content/common/view_messages.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/common/content_paths.h"
#include "content/public/test/mock_resource_context.h"
#include "content/public/test/test_browser_thread.h"
#include "content/renderer/media/audio_device_factory.h"
#include "content/renderer/media/audio_hardware.h"
#include "content/renderer/media/audio_input_message_filter.h"
#include "content/renderer/media/audio_message_filter.h"
#include "content/renderer/media/webrtc_audio_device_impl.h"
#include "content/renderer/render_process.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/renderer_webkitplatformsupport_impl.h"
#include "net/url_request/url_request_test_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/webrtc/voice_engine/include/voe_audio_processing.h"
#include "third_party/webrtc/voice_engine/include/voe_base.h"
#include "third_party/webrtc/voice_engine/include/voe_file.h"
#include "third_party/webrtc/voice_engine/include/voe_network.h"
#if defined(OS_WIN)
#include "base/win/scoped_com_initializer.h"
#endif
using testing::_;
using testing::InvokeWithoutArgs;
using testing::Return;
using testing::StrEq;
namespace content {
// This class is a mock of the child process singleton which is needed
// to be able to create a RenderThread object.
class WebRTCMockRenderProcess : public RenderProcess {
public:
WebRTCMockRenderProcess() {}
virtual ~WebRTCMockRenderProcess() {}
// RenderProcess implementation.
virtual skia::PlatformCanvas* GetDrawingCanvas(
TransportDIB** memory, const gfx::Rect& rect) OVERRIDE {
return NULL;
}
virtual void ReleaseTransportDIB(TransportDIB* memory) OVERRIDE {}
virtual bool UseInProcessPlugins() const OVERRIDE { return false; }
virtual void AddBindings(int bindings) OVERRIDE {}
virtual int GetEnabledBindings() const { return 0; }
virtual TransportDIB* CreateTransportDIB(size_t size) { return NULL; }
virtual void FreeTransportDIB(TransportDIB*) {}
private:
DISALLOW_COPY_AND_ASSIGN(WebRTCMockRenderProcess);
};
// Utility scoped class to replace the global content client's renderer for the
// duration of the test.
class ReplaceContentClientRenderer {
public:
explicit ReplaceContentClientRenderer(ContentRendererClient* new_renderer) {
saved_renderer_ = GetContentClient()->renderer();
GetContentClient()->set_renderer_for_testing(new_renderer);
}
~ReplaceContentClientRenderer() {
// Restore the original renderer.
GetContentClient()->set_renderer_for_testing(saved_renderer_);
}
private:
ContentRendererClient* saved_renderer_;
DISALLOW_COPY_AND_ASSIGN(ReplaceContentClientRenderer);
};
class MockRTCResourceContext : public ResourceContext {
public:
MockRTCResourceContext() : test_request_context_(NULL) {}
virtual ~MockRTCResourceContext() {}
void set_request_context(net::URLRequestContext* request_context) {
test_request_context_ = request_context;
}
// ResourceContext implementation:
virtual net::HostResolver* GetHostResolver() OVERRIDE {
return NULL;
}
virtual net::URLRequestContext* GetRequestContext() OVERRIDE {
return test_request_context_;
}
private:
net::URLRequestContext* test_request_context_;
DISALLOW_COPY_AND_ASSIGN(MockRTCResourceContext);
};
ACTION_P(QuitMessageLoop, loop_or_proxy) {
loop_or_proxy->PostTask(FROM_HERE, MessageLoop::QuitClosure());
}
WebRTCAudioDeviceTest::WebRTCAudioDeviceTest()
: render_thread_(NULL), audio_util_callback_(NULL),
has_input_devices_(false), has_output_devices_(false) {
}
WebRTCAudioDeviceTest::~WebRTCAudioDeviceTest() {}
void WebRTCAudioDeviceTest::SetUp() {
// This part sets up a RenderThread environment to ensure that
// RenderThread::current() (<=> TLS pointer) is valid.
// Main parts are inspired by the RenderViewFakeResourcesTest.
// Note that, the IPC part is not utilized in this test.
saved_content_renderer_.reset(
new ReplaceContentClientRenderer(&content_renderer_client_));
mock_process_.reset(new WebRTCMockRenderProcess());
ui_thread_.reset(new TestBrowserThread(BrowserThread::UI,
MessageLoop::current()));
// Create our own AudioManager and MediaStreamManager.
audio_manager_.reset(media::AudioManager::Create());
media_stream_manager_.reset(
new media_stream::MediaStreamManager(audio_manager_.get()));
// Construct the resource context on the UI thread.
resource_context_.reset(new MockRTCResourceContext);
static const char kThreadName[] = "RenderThread";
ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
base::Bind(&WebRTCAudioDeviceTest::InitializeIOThread,
base::Unretained(this), kThreadName));
WaitForIOThreadCompletion();
sandbox_was_enabled_ =
RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(false);
render_thread_ = new RenderThreadImpl(kThreadName);
}
void WebRTCAudioDeviceTest::TearDown() {
SetAudioUtilCallback(NULL);
// Run any pending cleanup tasks that may have been posted to the main thread.
ChildProcess::current()->main_thread()->message_loop()->RunAllPending();
// Kick of the cleanup process by closing the channel. This queues up
// OnStreamClosed calls to be executed on the audio thread.
ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
base::Bind(&WebRTCAudioDeviceTest::DestroyChannel,
base::Unretained(this)));
WaitForIOThreadCompletion();
// When audio [input] render hosts are notified that the channel has
// been closed, they post tasks to the audio thread to close the
// AudioOutputController and once that's completed, a task is posted back to
// the IO thread to actually delete the AudioEntry for the audio stream. Only
// then is the reference to the audio manager released, so we wait for the
// whole thing to be torn down before we finally uninitialize the io thread.
WaitForAudioManagerCompletion();
ChildProcess::current()->io_message_loop()->PostTask(FROM_HERE,
base::Bind(&WebRTCAudioDeviceTest::UninitializeIOThread,
base::Unretained((this))));
WaitForIOThreadCompletion();
mock_process_.reset();
media_stream_manager_.reset();
audio_manager_.reset();
RendererWebKitPlatformSupportImpl::SetSandboxEnabledForTesting(
sandbox_was_enabled_);
}
bool WebRTCAudioDeviceTest::Send(IPC::Message* message) {
return channel_->Send(message);
}
void WebRTCAudioDeviceTest::SetAudioUtilCallback(AudioUtilInterface* callback) {
// Invalidate any potentially cached values since the new callback should
// be used for those queries.
AudioHardware::ResetCache();
audio_util_callback_ = callback;
}
void WebRTCAudioDeviceTest::InitializeIOThread(const char* thread_name) {
#if defined(OS_WIN)
// We initialize COM (STA) on our IO thread as is done in Chrome.
// See BrowserProcessSubThread::Init.
initialize_com_.reset(new base::win::ScopedCOMInitializer());
#endif
// Set the current thread as the IO thread.
io_thread_.reset(new TestBrowserThread(BrowserThread::IO,
MessageLoop::current()));
// Populate our resource context.
test_request_context_.reset(new TestURLRequestContext());
MockRTCResourceContext* resource_context =
static_cast<MockRTCResourceContext*>(resource_context_.get());
resource_context->set_request_context(test_request_context_.get());
media_observer_.reset(new MockMediaObserver());
has_input_devices_ = audio_manager_->HasAudioInputDevices();
has_output_devices_ = audio_manager_->HasAudioOutputDevices();
// Create an IPC channel that handles incoming messages on the IO thread.
CreateChannel(thread_name);
}
void WebRTCAudioDeviceTest::UninitializeIOThread() {
resource_context_.reset();
test_request_context_.reset();
#if defined(OS_WIN)
initialize_com_.reset();
#endif
}
void WebRTCAudioDeviceTest::CreateChannel(const char* name) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
audio_render_host_ = new AudioRendererHost(
audio_manager_.get(), media_observer_.get());
audio_render_host_->OnChannelConnected(base::GetCurrentProcId());
audio_input_renderer_host_ = new AudioInputRendererHost(
audio_manager_.get(), media_stream_manager_.get());
audio_input_renderer_host_->OnChannelConnected(base::GetCurrentProcId());
channel_.reset(new IPC::Channel(name, IPC::Channel::MODE_SERVER, this));
ASSERT_TRUE(channel_->Connect());
audio_render_host_->OnFilterAdded(channel_.get());
audio_input_renderer_host_->OnFilterAdded(channel_.get());
}
void WebRTCAudioDeviceTest::DestroyChannel() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
audio_render_host_->OnChannelClosing();
audio_render_host_->OnFilterRemoved();
audio_input_renderer_host_->OnChannelClosing();
audio_input_renderer_host_->OnFilterRemoved();
channel_.reset();
audio_render_host_ = NULL;
audio_input_renderer_host_ = NULL;
}
void WebRTCAudioDeviceTest::OnGetHardwareSampleRate(int* sample_rate) {
EXPECT_TRUE(audio_util_callback_);
*sample_rate = audio_util_callback_ ?
audio_util_callback_->GetAudioHardwareSampleRate() : 0;
}
void WebRTCAudioDeviceTest::OnGetHardwareInputSampleRate(int* sample_rate) {
EXPECT_TRUE(audio_util_callback_);
*sample_rate = audio_util_callback_ ?
audio_util_callback_->GetAudioInputHardwareSampleRate(
media::AudioManagerBase::kDefaultDeviceId) : 0;
}
void WebRTCAudioDeviceTest::OnGetHardwareInputChannelLayout(
media::ChannelLayout* layout) {
EXPECT_TRUE(audio_util_callback_);
*layout = !audio_util_callback_ ? media::CHANNEL_LAYOUT_NONE :
audio_util_callback_->GetAudioInputHardwareChannelLayout(
media::AudioManagerBase::kDefaultDeviceId);
}
// IPC::Listener implementation.
bool WebRTCAudioDeviceTest::OnMessageReceived(const IPC::Message& message) {
if (render_thread_) {
IPC::ChannelProxy::MessageFilter* filter =
render_thread_->audio_input_message_filter();
if (filter->OnMessageReceived(message))
return true;
filter = render_thread_->audio_message_filter();
if (filter->OnMessageReceived(message))
return true;
}
if (audio_render_host_.get()) {
bool message_was_ok = false;
if (audio_render_host_->OnMessageReceived(message, &message_was_ok))
return true;
}
if (audio_input_renderer_host_.get()) {
bool message_was_ok = false;
if (audio_input_renderer_host_->OnMessageReceived(message, &message_was_ok))
return true;
}
bool handled ALLOW_UNUSED = true;
bool message_is_ok = true;
IPC_BEGIN_MESSAGE_MAP_EX(WebRTCAudioDeviceTest, message, message_is_ok)
IPC_MESSAGE_HANDLER(ViewHostMsg_GetHardwareSampleRate,
OnGetHardwareSampleRate)
IPC_MESSAGE_HANDLER(ViewHostMsg_GetHardwareInputSampleRate,
OnGetHardwareInputSampleRate)
IPC_MESSAGE_HANDLER(ViewHostMsg_GetHardwareInputChannelLayout,
OnGetHardwareInputChannelLayout)
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP_EX()
EXPECT_TRUE(message_is_ok);
return true;
}
// Posts a final task to the IO message loop and waits for completion.
void WebRTCAudioDeviceTest::WaitForIOThreadCompletion() {
WaitForMessageLoopCompletion(
ChildProcess::current()->io_message_loop()->message_loop_proxy());
}
void WebRTCAudioDeviceTest::WaitForAudioManagerCompletion() {
if (audio_manager_.get())
WaitForMessageLoopCompletion(audio_manager_->GetMessageLoop());
}
void WebRTCAudioDeviceTest::WaitForMessageLoopCompletion(
base::MessageLoopProxy* loop) {
base::WaitableEvent* event = new base::WaitableEvent(false, false);
loop->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
base::Unretained(event)));
if (event->TimedWait(TestTimeouts::action_max_timeout())) {
delete event;
} else {
// Don't delete the event object in case the message ever gets processed.
// If we do, we will crash the test process.
ADD_FAILURE() << "Failed to wait for message loop";
}
}
std::string WebRTCAudioDeviceTest::GetTestDataPath(
const FilePath::StringType& file_name) {
FilePath path;
EXPECT_TRUE(PathService::Get(DIR_TEST_DATA, &path));
path = path.Append(file_name);
EXPECT_TRUE(file_util::PathExists(path));
#ifdef OS_WIN
return WideToUTF8(path.value());
#else
return path.value();
#endif
}
WebRTCTransportImpl::WebRTCTransportImpl(webrtc::VoENetwork* network)
: network_(network) {
}
WebRTCTransportImpl::~WebRTCTransportImpl() {}
int WebRTCTransportImpl::SendPacket(int channel, const void* data, int len) {
return network_->ReceivedRTPPacket(channel, data, len);
}
int WebRTCTransportImpl::SendRTCPPacket(int channel, const void* data,
int len) {
return network_->ReceivedRTCPPacket(channel, data, len);
}
} // namespace content
|