OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 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. | |
4 | |
5 #include "content/browser/renderer_host/media/audio_output_delegate.h" | |
6 | |
7 #include <stdint.h> | |
8 | |
9 #include <memory> | |
10 #include <utility> | |
11 | |
12 #include "base/bind.h" | |
13 #include "base/command_line.h" | |
14 #include "base/message_loop/message_loop.h" | |
15 #include "base/run_loop.h" | |
16 #include "content/browser/media/capture/audio_mirroring_manager.h" | |
17 #include "content/browser/renderer_host/media/media_stream_manager.h" | |
18 #include "content/public/browser/browser_thread.h" | |
19 #include "content/public/browser/media_observer.h" | |
20 #include "content/public/test/mock_render_process_host.h" | |
21 #include "content/public/test/test_browser_context.h" | |
22 #include "content/public/test/test_browser_thread_bundle.h" | |
23 #include "content/test/test_web_contents.h" | |
24 #include "media/audio/fake_audio_log_factory.h" | |
25 #include "media/audio/fake_audio_manager.h" | |
26 #include "media/base/media_switches.h" | |
27 #include "testing/gmock/include/gmock/gmock.h" | |
28 #include "testing/gtest/include/gtest/gtest.h" | |
29 | |
30 using ::testing::_; | |
31 using ::testing::InSequence; | |
32 using ::testing::NotNull; | |
33 using ::testing::StrictMock; | |
34 | |
35 // Not yet tested: | |
DaleCurtis
2016/12/01 19:33:07
Mark with TODO(maxmorin) if you're going to leave
| |
36 // - Interactions with AudioStreamMonitor (goes through WebContentsImpl, | |
37 // so it's a bit tricky). | |
38 // - Logging (small risk of bugs, not worth the effort). | |
39 // - That the returned socket/memory is correctly set up. | |
40 | |
41 namespace content { | |
42 | |
43 namespace { | |
44 | |
45 const int kRenderProcessId = 1; | |
46 const int kRenderFrameId = 5; | |
47 const int kStreamId = 50; | |
48 const char kDefaultDeviceId[] = ""; | |
49 | |
50 class MockAudioMirroringManager : public AudioMirroringManager { | |
51 public: | |
52 MOCK_METHOD3(AddDiverter, | |
53 void(int render_process_id, | |
54 int render_frame_id, | |
55 Diverter* diverter)); | |
56 MOCK_METHOD1(RemoveDiverter, void(Diverter* diverter)); | |
57 }; | |
58 | |
59 class MockObserver : public content::MediaObserver { | |
60 public: | |
61 void OnAudioCaptureDevicesChanged() override {} | |
62 void OnVideoCaptureDevicesChanged() override {} | |
63 void OnMediaRequestStateChanged(int render_process_id, | |
64 int render_frame_id, | |
65 int page_request_id, | |
66 const GURL& security_origin, | |
67 MediaStreamType stream_type, | |
68 MediaRequestState state) override {} | |
69 void OnSetCapturingLinkSecured(int render_process_id, | |
70 int render_frame_id, | |
71 int page_request_id, | |
72 MediaStreamType stream_type, | |
73 bool is_secure) override {} | |
74 | |
75 MOCK_METHOD2(OnCreatingAudioStream, | |
76 void(int render_process_id, int render_frame_id)); | |
77 }; | |
78 | |
79 class MockEventHandler : public AudioOutputDelegate::EventHandler { | |
80 public: | |
81 MOCK_METHOD1(OnStreamStateChanged, void(bool playing)); | |
82 MOCK_METHOD3(OnStreamCreated, | |
83 void(int stream_id, | |
84 base::SharedMemory* shared_memory, | |
85 base::CancelableSyncSocket* socket)); | |
86 MOCK_METHOD1(OnStreamError, void(int stream_id)); | |
87 }; | |
88 | |
89 class DummyAudioOutputStream : public media::AudioOutputStream { | |
90 public: | |
91 // AudioOutputSteam implementation: | |
92 bool Open() override { return true; } | |
93 void Start(AudioSourceCallback* cb) override {} | |
94 void Stop() override {} | |
95 void SetVolume(double volume) override {} | |
96 void GetVolume(double* volume) override { *volume = 1; } | |
97 void Close() override {} | |
98 }; | |
99 | |
100 } // namespace | |
101 | |
102 class AudioOutputDelegateTest : public testing::Test { | |
103 public: | |
104 AudioOutputDelegateTest() { | |
105 base::CommandLine::ForCurrentProcess()->AppendSwitch( | |
106 switches::kUseFakeDeviceForMediaStream); | |
107 | |
108 // This test uses real UI, IO and audio threads. | |
109 // AudioOutputDelegate mainly interacts with the IO and audio threads, | |
110 // but interacts with UI for bad messages, so using these threads should | |
111 // approximate the real conditions of AudioOutputDelegate well. | |
112 thread_bundle_ = base::MakeUnique<TestBrowserThreadBundle>( | |
113 TestBrowserThreadBundle::Options::REAL_IO_THREAD); | |
114 audio_thread_ = base::MakeUnique<base::Thread>("AudioThread"); | |
115 | |
116 // Audio manager creation stolen from content/browser/browser_main_loop.cc. | |
117 #if defined(OS_WIN) | |
118 audio_thread_->init_com_with_mta(true); | |
119 #endif // defined(OS_WIN) | |
120 CHECK(audio_thread_->Start()); | |
121 | |
122 #if defined(OS_MACOSX) | |
123 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner = | |
124 base::ThreadTaskRunnerHandle::Get(); | |
125 #else | |
126 scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner = | |
127 audio_thread_->task_runner(); | |
128 #endif // defined(OS_MACOSX) | |
129 | |
130 audio_manager_.reset(new media::FakeAudioManager( | |
131 audio_task_runner, audio_thread_->task_runner(), &log_factory_)); | |
132 media_stream_manager_ = | |
133 base::MakeUnique<MediaStreamManager>(audio_manager_.get()); | |
134 } | |
135 | |
136 // Test bodies are here, so that we can run them on the IO thread. | |
137 void CreateTest(base::Closure done) { | |
138 EXPECT_CALL(media_observer_, | |
139 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
140 EXPECT_CALL(event_handler_, | |
141 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
142 EXPECT_CALL(mirroring_manager_, | |
143 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
144 | |
145 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
146 &event_handler_, audio_manager_.get(), | |
147 log_factory_.CreateAudioLog( | |
148 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
149 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
150 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
151 kDefaultDeviceId); | |
152 | |
153 SyncWithAllThreads(); | |
154 | |
155 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
156 delegate.reset(); | |
157 SyncWithAllThreads(); | |
158 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
159 } | |
160 | |
161 void PlayTest(base::Closure done) { | |
162 EXPECT_CALL(media_observer_, | |
163 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
164 EXPECT_CALL(event_handler_, | |
165 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
166 EXPECT_CALL(mirroring_manager_, | |
167 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
168 { | |
169 InSequence s; | |
170 EXPECT_CALL(event_handler_, OnStreamStateChanged(true)); | |
171 EXPECT_CALL(event_handler_, OnStreamStateChanged(false)); | |
172 } | |
173 | |
174 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
175 &event_handler_, audio_manager_.get(), | |
176 log_factory_.CreateAudioLog( | |
177 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
178 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
179 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
180 kDefaultDeviceId); | |
181 | |
182 delegate->OnPlayStream(); | |
183 | |
184 SyncWithAllThreads(); | |
185 | |
186 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
187 delegate.reset(); | |
188 SyncWithAllThreads(); | |
189 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
190 } | |
191 | |
192 void PauseTest(base::Closure done) { | |
193 EXPECT_CALL(media_observer_, | |
194 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
195 EXPECT_CALL(event_handler_, | |
196 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
197 EXPECT_CALL(mirroring_manager_, | |
198 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
199 | |
200 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
201 &event_handler_, audio_manager_.get(), | |
202 log_factory_.CreateAudioLog( | |
203 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
204 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
205 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
206 kDefaultDeviceId); | |
207 | |
208 delegate->OnPauseStream(); | |
209 | |
210 SyncWithAllThreads(); | |
211 | |
212 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
213 delegate.reset(); | |
214 SyncWithAllThreads(); | |
215 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
216 } | |
217 | |
218 void PlayPausePlayTest(base::Closure done) { | |
219 EXPECT_CALL(media_observer_, | |
220 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
221 EXPECT_CALL(event_handler_, | |
222 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
223 EXPECT_CALL(mirroring_manager_, | |
224 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
225 { | |
226 InSequence s; | |
227 EXPECT_CALL(event_handler_, OnStreamStateChanged(true)); | |
228 EXPECT_CALL(event_handler_, OnStreamStateChanged(false)); | |
229 EXPECT_CALL(event_handler_, OnStreamStateChanged(true)); | |
230 EXPECT_CALL(event_handler_, OnStreamStateChanged(false)); | |
231 } | |
232 | |
233 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
234 &event_handler_, audio_manager_.get(), | |
235 log_factory_.CreateAudioLog( | |
236 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
237 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
238 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
239 kDefaultDeviceId); | |
240 | |
241 delegate->OnPlayStream(); | |
242 delegate->OnPauseStream(); | |
243 delegate->OnPlayStream(); | |
244 | |
245 SyncWithAllThreads(); | |
246 | |
247 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
248 delegate.reset(); | |
249 SyncWithAllThreads(); | |
250 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
251 } | |
252 | |
253 void PlayPlayTest(base::Closure done) { | |
254 EXPECT_CALL(media_observer_, | |
255 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
256 EXPECT_CALL(event_handler_, | |
257 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
258 EXPECT_CALL(mirroring_manager_, | |
259 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
260 { | |
261 InSequence s; | |
262 EXPECT_CALL(event_handler_, OnStreamStateChanged(true)); | |
263 EXPECT_CALL(event_handler_, OnStreamStateChanged(false)); | |
264 } | |
265 | |
266 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
267 &event_handler_, audio_manager_.get(), | |
268 log_factory_.CreateAudioLog( | |
269 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
270 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
271 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
272 kDefaultDeviceId); | |
273 | |
274 delegate->OnPlayStream(); | |
275 delegate->OnPlayStream(); | |
276 | |
277 SyncWithAllThreads(); | |
278 | |
279 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
280 delegate.reset(); | |
281 SyncWithAllThreads(); | |
282 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
283 } | |
284 | |
285 void CreateDivertTest(base::Closure done) { | |
286 EXPECT_CALL(media_observer_, | |
287 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
288 EXPECT_CALL(event_handler_, | |
289 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
290 EXPECT_CALL(mirroring_manager_, | |
291 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
292 | |
293 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
294 &event_handler_, audio_manager_.get(), | |
295 log_factory_.CreateAudioLog( | |
296 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
297 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
298 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
299 kDefaultDeviceId); | |
300 | |
301 DummyAudioOutputStream stream; | |
302 delegate->controller()->StartDiverting(&stream); | |
303 | |
304 SyncWithAllThreads(); | |
305 | |
306 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
307 delegate.reset(); | |
308 SyncWithAllThreads(); | |
309 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
310 } | |
311 | |
312 void CreateDivertPauseTest(base::Closure done) { | |
313 EXPECT_CALL(media_observer_, | |
314 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
315 EXPECT_CALL(event_handler_, | |
316 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
317 EXPECT_CALL(mirroring_manager_, | |
318 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
319 | |
320 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
321 &event_handler_, audio_manager_.get(), | |
322 log_factory_.CreateAudioLog( | |
323 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
324 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
325 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
326 kDefaultDeviceId); | |
327 | |
328 DummyAudioOutputStream stream; | |
329 delegate->controller()->StartDiverting(&stream); | |
330 | |
331 SyncWithAllThreads(); | |
332 delegate->OnPauseStream(); | |
333 | |
334 SyncWithAllThreads(); | |
335 | |
336 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
337 delegate.reset(); | |
338 SyncWithAllThreads(); | |
339 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
340 } | |
341 | |
342 void PlayDivertTest(base::Closure done) { | |
343 EXPECT_CALL(media_observer_, | |
344 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
345 EXPECT_CALL(event_handler_, | |
346 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
347 EXPECT_CALL(mirroring_manager_, | |
348 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
349 { | |
350 InSequence s; | |
351 EXPECT_CALL(event_handler_, OnStreamStateChanged(true)); | |
352 EXPECT_CALL(event_handler_, OnStreamStateChanged(false)); | |
353 } | |
354 | |
355 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
356 &event_handler_, audio_manager_.get(), | |
357 log_factory_.CreateAudioLog( | |
358 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
359 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
360 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
361 kDefaultDeviceId); | |
362 | |
363 DummyAudioOutputStream stream; | |
364 delegate->OnPlayStream(); | |
365 delegate->controller()->StartDiverting(&stream); | |
366 | |
367 SyncWithAllThreads(); | |
368 | |
369 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
370 delegate.reset(); | |
371 SyncWithAllThreads(); | |
372 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
373 } | |
374 | |
375 void ErrorTest(base::Closure done) { | |
376 EXPECT_CALL(media_observer_, | |
377 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
378 EXPECT_CALL(event_handler_, | |
379 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
380 EXPECT_CALL(event_handler_, OnStreamError(kStreamId)); | |
381 EXPECT_CALL(mirroring_manager_, | |
382 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
383 | |
384 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
385 &event_handler_, audio_manager_.get(), | |
386 log_factory_.CreateAudioLog( | |
387 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
388 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
389 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
390 kDefaultDeviceId); | |
391 | |
392 delegate->controller()->OnError(nullptr); | |
393 | |
394 SyncWithAllThreads(); | |
395 | |
396 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
397 delegate.reset(); | |
398 SyncWithAllThreads(); | |
399 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
400 } | |
401 | |
402 void CreateAndDestroyTest(base::Closure done) { | |
403 EXPECT_CALL(media_observer_, | |
404 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
405 EXPECT_CALL(mirroring_manager_, | |
406 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
407 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
408 | |
409 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
410 &event_handler_, audio_manager_.get(), | |
411 log_factory_.CreateAudioLog( | |
412 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
413 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
414 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
415 kDefaultDeviceId); | |
416 | |
417 delegate.reset(); | |
418 SyncWithAllThreads(); | |
419 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
420 } | |
421 | |
422 void PlayAndDestroyTest(base::Closure done) { | |
423 EXPECT_CALL(media_observer_, | |
424 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
425 EXPECT_CALL(event_handler_, | |
426 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
427 EXPECT_CALL(mirroring_manager_, | |
428 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
429 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
430 | |
431 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
432 &event_handler_, audio_manager_.get(), | |
433 log_factory_.CreateAudioLog( | |
434 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
435 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
436 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
437 kDefaultDeviceId); | |
438 | |
439 SyncWithAllThreads(); | |
440 | |
441 delegate->OnPlayStream(); | |
442 delegate.reset(); | |
443 SyncWithAllThreads(); | |
444 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
445 } | |
446 | |
447 void ErrorAndDestroyTest(base::Closure done) { | |
448 EXPECT_CALL(media_observer_, | |
449 OnCreatingAudioStream(kRenderProcessId, kRenderFrameId)); | |
450 EXPECT_CALL(event_handler_, | |
451 OnStreamCreated(kStreamId, NotNull(), NotNull())); | |
452 EXPECT_CALL(mirroring_manager_, | |
453 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull())); | |
454 EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull())); | |
455 | |
456 AudioOutputDelegate::ScopedPtr delegate = AudioOutputDelegate::Create( | |
457 &event_handler_, audio_manager_.get(), | |
458 log_factory_.CreateAudioLog( | |
459 media::AudioLogFactory::AUDIO_OUTPUT_CONTROLLER), | |
460 &mirroring_manager_, &media_observer_, kStreamId, kRenderFrameId, | |
461 kRenderProcessId, audio_manager_->GetDefaultOutputStreamParameters(), | |
462 kDefaultDeviceId); | |
463 SyncWithAllThreads(); | |
464 | |
465 delegate->controller()->OnError(nullptr); | |
466 delegate.reset(); | |
467 SyncWithAllThreads(); | |
468 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, done); | |
469 } | |
470 | |
471 protected: | |
472 // MediaStreamManager uses a DestructionObserver, so it must outlive the | |
473 // TestBrowserThreadBundle. | |
474 std::unique_ptr<MediaStreamManager> media_stream_manager_; | |
475 std::unique_ptr<TestBrowserThreadBundle> thread_bundle_; | |
476 std::unique_ptr<base::Thread> audio_thread_; | |
477 media::ScopedAudioManagerPtr audio_manager_; | |
478 StrictMock<MockAudioMirroringManager> mirroring_manager_; | |
479 StrictMock<MockEventHandler> event_handler_; | |
480 StrictMock<MockObserver> media_observer_; | |
481 media::FakeAudioLogFactory log_factory_; | |
482 | |
483 private: | |
484 void SyncWithAllThreads() { | |
485 DCHECK_CURRENTLY_ON(BrowserThread::IO); | |
486 // New tasks might be posted while we are syncing, but in every iteration at | |
487 // least one task will be run. 20 iterations should be enough for our code. | |
488 for (int i = 0; i < 20; ++i) { | |
489 { | |
490 base::MessageLoop::ScopedNestableTaskAllower allower( | |
491 base::MessageLoop::current()); | |
492 base::RunLoop().RunUntilIdle(); | |
493 } | |
494 SyncWith(BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)); | |
495 SyncWith(audio_thread_->task_runner()); | |
496 } | |
497 } | |
498 | |
499 void SyncWith(scoped_refptr<base::SingleThreadTaskRunner> task_runner) { | |
500 CHECK(task_runner); | |
501 CHECK(!task_runner->BelongsToCurrentThread()); | |
502 base::WaitableEvent e = {base::WaitableEvent::ResetPolicy::MANUAL, | |
503 base::WaitableEvent::InitialState::NOT_SIGNALED}; | |
504 task_runner->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal, | |
505 base::Unretained(&e))); | |
506 e.Wait(); | |
507 } | |
508 | |
509 DISALLOW_COPY_AND_ASSIGN(AudioOutputDelegateTest); | |
510 }; | |
511 | |
512 TEST_F(AudioOutputDelegateTest, Create) { | |
513 base::RunLoop l; | |
514 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
515 base::Bind(&AudioOutputDelegateTest::CreateTest, | |
516 base::Unretained(this), l.QuitClosure())); | |
517 l.Run(); | |
518 } | |
519 | |
520 TEST_F(AudioOutputDelegateTest, Play) { | |
521 base::RunLoop l; | |
522 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
523 base::Bind(&AudioOutputDelegateTest::PlayTest, | |
524 base::Unretained(this), l.QuitClosure())); | |
525 l.Run(); | |
526 } | |
527 | |
528 TEST_F(AudioOutputDelegateTest, Pause) { | |
529 base::RunLoop l; | |
530 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
531 base::Bind(&AudioOutputDelegateTest::PauseTest, | |
532 base::Unretained(this), l.QuitClosure())); | |
533 l.Run(); | |
534 } | |
535 | |
536 TEST_F(AudioOutputDelegateTest, PlayPausePlay) { | |
537 base::RunLoop l; | |
538 BrowserThread::PostTask( | |
539 BrowserThread::IO, FROM_HERE, | |
540 base::Bind(&AudioOutputDelegateTest::PlayPausePlayTest, | |
541 base::Unretained(this), l.QuitClosure())); | |
542 l.Run(); | |
543 } | |
544 | |
545 TEST_F(AudioOutputDelegateTest, PlayPlay) { | |
546 base::RunLoop l; | |
547 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
548 base::Bind(&AudioOutputDelegateTest::PlayPlayTest, | |
549 base::Unretained(this), l.QuitClosure())); | |
550 l.Run(); | |
551 } | |
552 | |
553 TEST_F(AudioOutputDelegateTest, PlayDivert) { | |
554 base::RunLoop l; | |
555 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
556 base::Bind(&AudioOutputDelegateTest::PlayDivertTest, | |
557 base::Unretained(this), l.QuitClosure())); | |
558 l.Run(); | |
559 } | |
560 | |
561 TEST_F(AudioOutputDelegateTest, CreateDivert) { | |
562 base::RunLoop l; | |
563 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
564 base::Bind(&AudioOutputDelegateTest::CreateDivertTest, | |
565 base::Unretained(this), l.QuitClosure())); | |
566 l.Run(); | |
567 } | |
568 | |
569 TEST_F(AudioOutputDelegateTest, Error) { | |
570 base::RunLoop l; | |
571 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
572 base::Bind(&AudioOutputDelegateTest::ErrorTest, | |
573 base::Unretained(this), l.QuitClosure())); | |
574 l.Run(); | |
575 } | |
576 | |
577 TEST_F(AudioOutputDelegateTest, CreateAndDestroy) { | |
578 base::RunLoop l; | |
579 BrowserThread::PostTask( | |
580 BrowserThread::IO, FROM_HERE, | |
581 base::Bind(&AudioOutputDelegateTest::CreateAndDestroyTest, | |
582 base::Unretained(this), l.QuitClosure())); | |
583 l.Run(); | |
584 } | |
585 | |
586 TEST_F(AudioOutputDelegateTest, PlayAndDestroy) { | |
587 base::RunLoop l; | |
588 BrowserThread::PostTask( | |
589 BrowserThread::IO, FROM_HERE, | |
590 base::Bind(&AudioOutputDelegateTest::PlayAndDestroyTest, | |
591 base::Unretained(this), l.QuitClosure())); | |
592 l.Run(); | |
593 } | |
594 | |
595 TEST_F(AudioOutputDelegateTest, ErrorAndDestroy) { | |
596 base::RunLoop l; | |
597 BrowserThread::PostTask( | |
598 BrowserThread::IO, FROM_HERE, | |
599 base::Bind(&AudioOutputDelegateTest::PlayAndDestroyTest, | |
600 base::Unretained(this), l.QuitClosure())); | |
601 l.Run(); | |
602 } | |
603 | |
604 } // namespace content | |
OLD | NEW |