Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(118)

Side by Side Diff: content/browser/renderer_host/media/audio_output_delegate_unittest.cc

Issue 2443573003: Factor out AudioOutputDelegate from AudioRendererHost. (Closed)
Patch Set: . Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698