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