OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/media/webrtc/native_desktop_media_list.h" | 5 #include "chrome/browser/media/webrtc/native_desktop_media_list.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 #include <string.h> | 9 #include <string.h> |
10 #include <utility> | 10 #include <utility> |
11 #include <vector> | 11 #include <vector> |
12 | 12 |
13 #include "base/location.h" | 13 #include "base/location.h" |
14 #include "base/macros.h" | 14 #include "base/macros.h" |
15 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
16 #include "base/single_thread_task_runner.h" | 16 #include "base/single_thread_task_runner.h" |
17 #include "base/strings/utf_string_conversions.h" | 17 #include "base/strings/utf_string_conversions.h" |
18 #include "base/synchronization/lock.h" | 18 #include "base/synchronization/lock.h" |
| 19 #include "base/threading/thread_task_runner_handle.h" |
19 #include "chrome/browser/media/webrtc/desktop_media_list_observer.h" | 20 #include "chrome/browser/media/webrtc/desktop_media_list_observer.h" |
20 #include "content/public/test/test_browser_thread.h" | 21 #include "content/public/test/test_browser_thread_bundle.h" |
21 #include "testing/gmock/include/gmock/gmock.h" | 22 #include "testing/gmock/include/gmock/gmock.h" |
22 #include "testing/gtest/include/gtest/gtest.h" | 23 #include "testing/gtest/include/gtest/gtest.h" |
23 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h" | 24 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h" |
24 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h" | 25 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h" |
25 #include "ui/aura/window.h" | 26 #include "ui/aura/window.h" |
26 #include "ui/aura/window_tree_host.h" | 27 #include "ui/aura/window_tree_host.h" |
27 #include "ui/views/test/views_test_base.h" | 28 #include "ui/views/test/views_test_base.h" |
28 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h" | 29 #include "ui/views/widget/desktop_aura/desktop_native_widget_aura.h" |
29 #include "ui/views/widget/widget.h" | 30 #include "ui/views/widget/widget.h" |
30 | 31 |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
154 | 155 |
155 DISALLOW_COPY_AND_ASSIGN(FakeWindowCapturer); | 156 DISALLOW_COPY_AND_ASSIGN(FakeWindowCapturer); |
156 }; | 157 }; |
157 | 158 |
158 } // namespace | 159 } // namespace |
159 | 160 |
160 ACTION_P2(CheckListSize, model, expected_list_size) { | 161 ACTION_P2(CheckListSize, model, expected_list_size) { |
161 EXPECT_EQ(expected_list_size, model->GetSourceCount()); | 162 EXPECT_EQ(expected_list_size, model->GetSourceCount()); |
162 } | 163 } |
163 | 164 |
164 ACTION_P(QuitMessageLoop, message_loop) { | 165 ACTION_P2(QuitRunLoop, task_runner, run_loop) { |
165 message_loop->task_runner()->PostTask( | 166 task_runner->PostTask(FROM_HERE, run_loop->QuitWhenIdleClosure()); |
166 FROM_HERE, base::MessageLoop::QuitWhenIdleClosure()); | |
167 } | 167 } |
168 | 168 |
169 class NativeDesktopMediaListTest : public views::ViewsTestBase { | 169 class NativeDesktopMediaListTest : public views::ViewsTestBase { |
170 public: | 170 public: |
171 NativeDesktopMediaListTest() | 171 NativeDesktopMediaListTest() = default; |
172 : ui_thread_(content::BrowserThread::UI, message_loop()) {} | |
173 | 172 |
174 void TearDown() override { | 173 void TearDown() override { |
175 for (size_t i = 0; i < desktop_widgets_.size(); i++) | 174 for (size_t i = 0; i < desktop_widgets_.size(); i++) |
176 desktop_widgets_[i].reset(); | 175 desktop_widgets_[i].reset(); |
177 | 176 |
178 ViewsTestBase::TearDown(); | 177 ViewsTestBase::TearDown(); |
179 } | 178 } |
180 | 179 |
181 void CreateWithCapturers(bool screen, bool window) { | 180 void CreateWithCapturers(bool screen, bool window) { |
182 webrtc::DesktopCapturer* screen_capturer = nullptr; | 181 webrtc::DesktopCapturer* screen_capturer = nullptr; |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
299 | 298 |
300 // Set view dialog window ID as the first window id. | 299 // Set view dialog window ID as the first window id. |
301 if (has_view_dialog) { | 300 if (has_view_dialog) { |
302 DesktopMediaID dialog_window_id(DesktopMediaID::TYPE_WINDOW, | 301 DesktopMediaID dialog_window_id(DesktopMediaID::TYPE_WINDOW, |
303 window_list_[0].id); | 302 window_list_[0].id); |
304 model_->SetViewDialogWindowId(dialog_window_id); | 303 model_->SetViewDialogWindowId(dialog_window_id); |
305 window_count--; | 304 window_count--; |
306 aura_window_first_index--; | 305 aura_window_first_index--; |
307 } | 306 } |
308 | 307 |
| 308 base::RunLoop run_loop; |
| 309 |
309 { | 310 { |
310 testing::InSequence dummy; | 311 testing::InSequence dummy; |
311 size_t source_count = screen ? window_count + 1 : window_count; | 312 size_t source_count = screen ? window_count + 1 : window_count; |
312 for (size_t i = 0; i < source_count; ++i) { | 313 for (size_t i = 0; i < source_count; ++i) { |
313 EXPECT_CALL(observer_, OnSourceAdded(model_.get(), i)) | 314 EXPECT_CALL(observer_, OnSourceAdded(model_.get(), i)) |
314 .WillOnce(CheckListSize(model_.get(), static_cast<int>(i + 1))); | 315 .WillOnce(CheckListSize(model_.get(), static_cast<int>(i + 1))); |
315 } | 316 } |
316 for (size_t i = 0; i < source_count - 1; ++i) { | 317 for (size_t i = 0; i < source_count - 1; ++i) { |
317 EXPECT_CALL(observer_, OnSourceThumbnailChanged(model_.get(), i)); | 318 EXPECT_CALL(observer_, OnSourceThumbnailChanged(model_.get(), i)); |
318 } | 319 } |
319 EXPECT_CALL(observer_, | 320 EXPECT_CALL(observer_, |
320 OnSourceThumbnailChanged(model_.get(), source_count - 1)) | 321 OnSourceThumbnailChanged(model_.get(), source_count - 1)) |
321 .WillOnce(QuitMessageLoop(message_loop())); | 322 .WillOnce( |
| 323 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop)); |
322 } | 324 } |
323 model_->StartUpdating(&observer_); | 325 model_->StartUpdating(&observer_); |
324 base::RunLoop().Run(); | 326 run_loop.Run(); |
325 | 327 |
326 if (screen) { | 328 if (screen) { |
327 EXPECT_EQ(model_->GetSource(0).id.type, DesktopMediaID::TYPE_SCREEN); | 329 EXPECT_EQ(model_->GetSource(0).id.type, DesktopMediaID::TYPE_SCREEN); |
328 EXPECT_EQ(model_->GetSource(0).id.id, 0); | 330 EXPECT_EQ(model_->GetSource(0).id.id, 0); |
329 } | 331 } |
330 | 332 |
331 for (size_t i = 0; i < window_count; ++i) { | 333 for (size_t i = 0; i < window_count; ++i) { |
332 size_t source_index = screen ? i + 1 : i; | 334 size_t source_index = screen ? i + 1 : i; |
333 EXPECT_EQ(model_->GetSource(source_index).id.type, | 335 EXPECT_EQ(model_->GetSource(source_index).id.type, |
334 DesktopMediaID::TYPE_WINDOW); | 336 DesktopMediaID::TYPE_WINDOW); |
335 EXPECT_EQ(model_->GetSource(source_index).name, | 337 EXPECT_EQ(model_->GetSource(source_index).name, |
336 base::UTF8ToUTF16("Test window")); | 338 base::UTF8ToUTF16("Test window")); |
337 int index = has_view_dialog ? i + 1 : i; | 339 int index = has_view_dialog ? i + 1 : i; |
338 int native_id = window_list_[index].id; | 340 int native_id = window_list_[index].id; |
339 EXPECT_EQ(model_->GetSource(source_index).id.id, native_id); | 341 EXPECT_EQ(model_->GetSource(source_index).id.id, native_id); |
340 #if defined(USE_AURA) | 342 #if defined(USE_AURA) |
341 if (i >= aura_window_first_index) | 343 if (i >= aura_window_first_index) |
342 EXPECT_EQ(model_->GetSource(source_index).id.aura_id, | 344 EXPECT_EQ(model_->GetSource(source_index).id.aura_id, |
343 native_aura_id_map_[native_id]); | 345 native_aura_id_map_[native_id]); |
344 #endif | 346 #endif |
345 } | 347 } |
346 testing::Mock::VerifyAndClearExpectations(&observer_); | 348 testing::Mock::VerifyAndClearExpectations(&observer_); |
347 } | 349 } |
348 | 350 |
349 protected: | 351 protected: |
| 352 content::TestBrowserThreadBundle test_browser_thread_bundle_; |
| 353 |
350 // Must be listed before |model_|, so it's destroyed last. | 354 // Must be listed before |model_|, so it's destroyed last. |
351 MockObserver observer_; | 355 MockObserver observer_; |
352 | 356 |
353 // Owned by |model_|; | 357 // Owned by |model_|; |
354 FakeWindowCapturer* window_capturer_; | 358 FakeWindowCapturer* window_capturer_; |
355 | 359 |
356 webrtc::DesktopCapturer::SourceList window_list_; | 360 webrtc::DesktopCapturer::SourceList window_list_; |
357 std::vector<std::unique_ptr<views::Widget>> desktop_widgets_; | 361 std::vector<std::unique_ptr<views::Widget>> desktop_widgets_; |
358 std::map<DesktopMediaID::Id, DesktopMediaID::Id> native_aura_id_map_; | 362 std::map<DesktopMediaID::Id, DesktopMediaID::Id> native_aura_id_map_; |
359 std::unique_ptr<NativeDesktopMediaList> model_; | 363 std::unique_ptr<NativeDesktopMediaList> model_; |
360 | 364 |
361 content::TestBrowserThread ui_thread_; | |
362 | |
363 DISALLOW_COPY_AND_ASSIGN(NativeDesktopMediaListTest); | 365 DISALLOW_COPY_AND_ASSIGN(NativeDesktopMediaListTest); |
364 }; | 366 }; |
365 | 367 |
366 TEST_F(NativeDesktopMediaListTest, WindowsOnly) { | 368 TEST_F(NativeDesktopMediaListTest, WindowsOnly) { |
367 AddWindowsAndVerify(false, kDefaultWindowCount, kDefaultAuraCount, false); | 369 AddWindowsAndVerify(false, kDefaultWindowCount, kDefaultAuraCount, false); |
368 } | 370 } |
369 | 371 |
370 TEST_F(NativeDesktopMediaListTest, ScreenOnly) { | 372 TEST_F(NativeDesktopMediaListTest, ScreenOnly) { |
371 AddWindowsAndVerify(true, 0, 0, false); | 373 AddWindowsAndVerify(true, 0, 0, false); |
372 } | 374 } |
373 | 375 |
374 // Verifies that the window specified with SetViewDialogWindowId() is filtered | 376 // Verifies that the window specified with SetViewDialogWindowId() is filtered |
375 // from the results. | 377 // from the results. |
376 TEST_F(NativeDesktopMediaListTest, Filtering) { | 378 TEST_F(NativeDesktopMediaListTest, Filtering) { |
377 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, true); | 379 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, true); |
378 } | 380 } |
379 | 381 |
380 TEST_F(NativeDesktopMediaListTest, AddNativeWindow) { | 382 TEST_F(NativeDesktopMediaListTest, AddNativeWindow) { |
381 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 383 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
382 | 384 |
| 385 base::RunLoop run_loop; |
| 386 |
383 const int index = kDefaultWindowCount + 1; | 387 const int index = kDefaultWindowCount + 1; |
384 EXPECT_CALL(observer_, OnSourceAdded(model_.get(), index)) | 388 EXPECT_CALL(observer_, OnSourceAdded(model_.get(), index)) |
385 .WillOnce(DoAll(CheckListSize(model_.get(), index + 1), | 389 .WillOnce( |
386 QuitMessageLoop(message_loop()))); | 390 DoAll(CheckListSize(model_.get(), index + 1), |
| 391 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop))); |
387 | 392 |
388 AddNativeWindow(index); | 393 AddNativeWindow(index); |
389 window_capturer_->SetWindowList(window_list_); | 394 window_capturer_->SetWindowList(window_list_); |
390 | 395 |
391 base::RunLoop().Run(); | 396 run_loop.Run(); |
392 | 397 |
393 EXPECT_EQ(model_->GetSource(index).id.type, DesktopMediaID::TYPE_WINDOW); | 398 EXPECT_EQ(model_->GetSource(index).id.type, DesktopMediaID::TYPE_WINDOW); |
394 EXPECT_EQ(model_->GetSource(index).id.id, index); | 399 EXPECT_EQ(model_->GetSource(index).id.id, index); |
395 } | 400 } |
396 | 401 |
397 #if defined(ENABLE_AURA_WINDOW_TESTS) | 402 #if defined(ENABLE_AURA_WINDOW_TESTS) |
398 TEST_F(NativeDesktopMediaListTest, AddAuraWindow) { | 403 TEST_F(NativeDesktopMediaListTest, AddAuraWindow) { |
399 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 404 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
400 | 405 |
| 406 base::RunLoop run_loop; |
| 407 |
401 const int index = kDefaultWindowCount + 1; | 408 const int index = kDefaultWindowCount + 1; |
402 EXPECT_CALL(observer_, OnSourceAdded(model_.get(), index)) | 409 EXPECT_CALL(observer_, OnSourceAdded(model_.get(), index)) |
403 .WillOnce(DoAll(CheckListSize(model_.get(), index + 1), | 410 .WillOnce( |
404 QuitMessageLoop(message_loop()))); | 411 DoAll(CheckListSize(model_.get(), index + 1), |
| 412 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop))); |
405 | 413 |
406 AddAuraWindow(); | 414 AddAuraWindow(); |
407 window_capturer_->SetWindowList(window_list_); | 415 window_capturer_->SetWindowList(window_list_); |
408 | 416 |
409 base::RunLoop().Run(); | 417 run_loop.Run(); |
410 | 418 |
411 int native_id = window_list_.back().id; | 419 int native_id = window_list_.back().id; |
412 EXPECT_EQ(model_->GetSource(index).id.type, DesktopMediaID::TYPE_WINDOW); | 420 EXPECT_EQ(model_->GetSource(index).id.type, DesktopMediaID::TYPE_WINDOW); |
413 EXPECT_EQ(model_->GetSource(index).id.id, native_id); | 421 EXPECT_EQ(model_->GetSource(index).id.id, native_id); |
414 EXPECT_EQ(model_->GetSource(index).id.aura_id, | 422 EXPECT_EQ(model_->GetSource(index).id.aura_id, |
415 native_aura_id_map_[native_id]); | 423 native_aura_id_map_[native_id]); |
416 } | 424 } |
417 #endif // defined(ENABLE_AURA_WINDOW_TESTS) | 425 #endif // defined(ENABLE_AURA_WINDOW_TESTS) |
418 | 426 |
419 TEST_F(NativeDesktopMediaListTest, RemoveNativeWindow) { | 427 TEST_F(NativeDesktopMediaListTest, RemoveNativeWindow) { |
420 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 428 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
421 | 429 |
| 430 base::RunLoop run_loop; |
| 431 |
422 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), 1)) | 432 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), 1)) |
423 .WillOnce(DoAll(CheckListSize(model_.get(), kDefaultWindowCount), | 433 .WillOnce( |
424 QuitMessageLoop(message_loop()))); | 434 DoAll(CheckListSize(model_.get(), kDefaultWindowCount), |
| 435 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop))); |
425 | 436 |
426 window_list_.erase(window_list_.begin()); | 437 window_list_.erase(window_list_.begin()); |
427 window_capturer_->SetWindowList(window_list_); | 438 window_capturer_->SetWindowList(window_list_); |
428 | 439 |
429 base::RunLoop().Run(); | 440 run_loop.Run(); |
430 } | 441 } |
431 | 442 |
432 #if defined(ENABLE_AURA_WINDOW_TESTS) | 443 #if defined(ENABLE_AURA_WINDOW_TESTS) |
433 TEST_F(NativeDesktopMediaListTest, RemoveAuraWindow) { | 444 TEST_F(NativeDesktopMediaListTest, RemoveAuraWindow) { |
434 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 445 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
435 | 446 |
| 447 base::RunLoop run_loop; |
| 448 |
436 int aura_window_start_index = kDefaultWindowCount - kDefaultAuraCount + 1; | 449 int aura_window_start_index = kDefaultWindowCount - kDefaultAuraCount + 1; |
437 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), aura_window_start_index)) | 450 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), aura_window_start_index)) |
438 .WillOnce(DoAll(CheckListSize(model_.get(), kDefaultWindowCount), | 451 .WillOnce( |
439 QuitMessageLoop(message_loop()))); | 452 DoAll(CheckListSize(model_.get(), kDefaultWindowCount), |
| 453 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop))); |
440 | 454 |
441 RemoveAuraWindow(0); | 455 RemoveAuraWindow(0); |
442 window_capturer_->SetWindowList(window_list_); | 456 window_capturer_->SetWindowList(window_list_); |
443 | 457 |
444 base::RunLoop().Run(); | 458 run_loop.Run(); |
445 } | 459 } |
446 #endif // defined(ENABLE_AURA_WINDOW_TESTS) | 460 #endif // defined(ENABLE_AURA_WINDOW_TESTS) |
447 | 461 |
448 TEST_F(NativeDesktopMediaListTest, RemoveAllWindows) { | 462 TEST_F(NativeDesktopMediaListTest, RemoveAllWindows) { |
449 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 463 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
450 | 464 |
| 465 base::RunLoop run_loop; |
| 466 |
451 testing::InSequence seq; | 467 testing::InSequence seq; |
452 for (int i = 0; i < kDefaultWindowCount - 1; i++) { | 468 for (int i = 0; i < kDefaultWindowCount - 1; i++) { |
453 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), 1)) | 469 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), 1)) |
454 .WillOnce(CheckListSize(model_.get(), kDefaultWindowCount - i)); | 470 .WillOnce(CheckListSize(model_.get(), kDefaultWindowCount - i)); |
455 } | 471 } |
456 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), 1)) | 472 EXPECT_CALL(observer_, OnSourceRemoved(model_.get(), 1)) |
457 .WillOnce(DoAll(CheckListSize(model_.get(), 1), | 473 .WillOnce( |
458 QuitMessageLoop(message_loop()))); | 474 DoAll(CheckListSize(model_.get(), 1), |
| 475 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop))); |
459 | 476 |
460 window_list_.clear(); | 477 window_list_.clear(); |
461 window_capturer_->SetWindowList(window_list_); | 478 window_capturer_->SetWindowList(window_list_); |
462 | 479 |
463 base::RunLoop().Run(); | 480 run_loop.Run(); |
464 } | 481 } |
465 | 482 |
466 TEST_F(NativeDesktopMediaListTest, UpdateTitle) { | 483 TEST_F(NativeDesktopMediaListTest, UpdateTitle) { |
467 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 484 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
468 | 485 |
| 486 base::RunLoop run_loop; |
| 487 |
469 EXPECT_CALL(observer_, OnSourceNameChanged(model_.get(), 1)) | 488 EXPECT_CALL(observer_, OnSourceNameChanged(model_.get(), 1)) |
470 .WillOnce(QuitMessageLoop(message_loop())); | 489 .WillOnce(QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop)); |
471 | 490 |
472 const std::string kTestTitle = "New Title"; | 491 const std::string kTestTitle = "New Title"; |
473 window_list_[0].title = kTestTitle; | 492 window_list_[0].title = kTestTitle; |
474 window_capturer_->SetWindowList(window_list_); | 493 window_capturer_->SetWindowList(window_list_); |
475 | 494 |
476 base::RunLoop().Run(); | 495 run_loop.Run(); |
477 | 496 |
478 EXPECT_EQ(model_->GetSource(1).name, base::UTF8ToUTF16(kTestTitle)); | 497 EXPECT_EQ(model_->GetSource(1).name, base::UTF8ToUTF16(kTestTitle)); |
479 } | 498 } |
480 | 499 |
481 TEST_F(NativeDesktopMediaListTest, UpdateThumbnail) { | 500 TEST_F(NativeDesktopMediaListTest, UpdateThumbnail) { |
482 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 501 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
483 | 502 |
484 // Aura windows' thumbnails may unpredictably change over time. | 503 // Aura windows' thumbnails may unpredictably change over time. |
485 for (size_t i = kDefaultWindowCount - kDefaultAuraCount; | 504 for (size_t i = kDefaultWindowCount - kDefaultAuraCount; |
486 i < kDefaultWindowCount; ++i) { | 505 i < kDefaultWindowCount; ++i) { |
487 EXPECT_CALL(observer_, OnSourceThumbnailChanged(model_.get(), i + 1)) | 506 EXPECT_CALL(observer_, OnSourceThumbnailChanged(model_.get(), i + 1)) |
488 .Times(testing::AnyNumber()); | 507 .Times(testing::AnyNumber()); |
489 } | 508 } |
490 | 509 |
| 510 base::RunLoop run_loop; |
| 511 |
491 EXPECT_CALL(observer_, OnSourceThumbnailChanged(model_.get(), 1)) | 512 EXPECT_CALL(observer_, OnSourceThumbnailChanged(model_.get(), 1)) |
492 .WillOnce(QuitMessageLoop(message_loop())); | 513 .WillOnce(QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop)); |
493 | 514 |
494 // Update frame for the window and verify that we get notification about it. | 515 // Update frame for the window and verify that we get notification about it. |
495 window_capturer_->SetNextFrameValue(1, 10); | 516 window_capturer_->SetNextFrameValue(1, 10); |
496 | 517 |
497 base::RunLoop().Run(); | 518 run_loop.Run(); |
498 } | 519 } |
499 | 520 |
500 TEST_F(NativeDesktopMediaListTest, MoveWindow) { | 521 TEST_F(NativeDesktopMediaListTest, MoveWindow) { |
501 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); | 522 AddWindowsAndVerify(true, kDefaultWindowCount, kDefaultAuraCount, false); |
502 | 523 |
| 524 base::RunLoop run_loop; |
| 525 |
503 EXPECT_CALL(observer_, OnSourceMoved(model_.get(), 2, 1)) | 526 EXPECT_CALL(observer_, OnSourceMoved(model_.get(), 2, 1)) |
504 .WillOnce(DoAll(CheckListSize(model_.get(), kDefaultWindowCount + 1), | 527 .WillOnce( |
505 QuitMessageLoop(message_loop()))); | 528 DoAll(CheckListSize(model_.get(), kDefaultWindowCount + 1), |
| 529 QuitRunLoop(base::ThreadTaskRunnerHandle::Get(), &run_loop))); |
506 | 530 |
507 std::swap(window_list_[0], window_list_[1]); | 531 std::swap(window_list_[0], window_list_[1]); |
508 window_capturer_->SetWindowList(window_list_); | 532 window_capturer_->SetWindowList(window_list_); |
509 | 533 |
510 base::RunLoop().Run(); | 534 run_loop.Run(); |
511 } | 535 } |
OLD | NEW |