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

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

Issue 2729783003: [Mojo Video Capture] Add content_browsertest for exercising video capture (Closed)
Patch Set: incorporated miu@'s suggestions Created 3 years, 9 months 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
« no previous file with comments | « content/browser/renderer_host/media/video_capture_manager.cc ('k') | content/test/BUILD.gn » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 1 // Copyright (c) 2012 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 // Unit test for VideoCaptureManager. 5 // Unit test for VideoCaptureManager.
6 6
7 #include "content/browser/renderer_host/media/video_capture_manager.h" 7 #include "content/browser/renderer_host/media/video_capture_manager.h"
8 8
9 #include <stdint.h> 9 #include <stdint.h>
10 10
(...skipping 289 matching lines...) Expand 10 before | Expand all | Expand 10 after
300 300
301 // Test cases 301 // Test cases
302 302
303 // Try to open, start, stop and close a device. 303 // Try to open, start, stop and close a device.
304 TEST_F(VideoCaptureManagerTest, CreateAndClose) { 304 TEST_F(VideoCaptureManagerTest, CreateAndClose) {
305 InSequence s; 305 InSequence s;
306 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 306 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
307 EXPECT_CALL(*frame_observer_, OnStarted(_)); 307 EXPECT_CALL(*frame_observer_, OnStarted(_));
308 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 308 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
309 309
310 int video_session_id = vcm_->Open(devices_.front()); 310 int video_session_id = vcm_->Open(devices_.front().device);
311 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 311 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
312 312
313 StopClient(client_id); 313 StopClient(client_id);
314 vcm_->Close(video_session_id); 314 vcm_->Close(video_session_id);
315 315
316 // Wait to check callbacks before removing the listener. 316 // Wait to check callbacks before removing the listener.
317 base::RunLoop().RunUntilIdle(); 317 base::RunLoop().RunUntilIdle();
318 vcm_->UnregisterListener(); 318 vcm_->UnregisterListener(listener_.get());
319 } 319 }
320 320
321 TEST_F(VideoCaptureManagerTest, CreateAndCloseMultipleTimes) { 321 TEST_F(VideoCaptureManagerTest, CreateAndCloseMultipleTimes) {
322 InSequence s; 322 InSequence s;
323 for (int i = 1 ; i < 3 ; ++i) { 323 for (int i = 1 ; i < 3 ; ++i) {
324 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, i)); 324 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, i));
325 EXPECT_CALL(*frame_observer_, OnStarted(_)); 325 EXPECT_CALL(*frame_observer_, OnStarted(_));
326 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, i)); 326 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, i));
327 int video_session_id = vcm_->Open(devices_.front()); 327 int video_session_id = vcm_->Open(devices_.front().device);
328 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 328 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
329 329
330 StopClient(client_id); 330 StopClient(client_id);
331 vcm_->Close(video_session_id); 331 vcm_->Close(video_session_id);
332 } 332 }
333 333
334 // Wait to check callbacks before removing the listener. 334 // Wait to check callbacks before removing the listener.
335 base::RunLoop().RunUntilIdle(); 335 base::RunLoop().RunUntilIdle();
336 vcm_->UnregisterListener(); 336 vcm_->UnregisterListener(listener_.get());
337 } 337 }
338 338
339 // Try to open, start, and abort a device. 339 // Try to open, start, and abort a device.
340 TEST_F(VideoCaptureManagerTest, CreateAndAbort) { 340 TEST_F(VideoCaptureManagerTest, CreateAndAbort) {
341 InSequence s; 341 InSequence s;
342 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 342 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
343 EXPECT_CALL(*frame_observer_, OnStarted(_)); 343 EXPECT_CALL(*frame_observer_, OnStarted(_));
344 EXPECT_CALL(*listener_, Aborted(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 344 EXPECT_CALL(*listener_, Aborted(MEDIA_DEVICE_VIDEO_CAPTURE, _));
345 345
346 int video_session_id = vcm_->Open(devices_.front()); 346 int video_session_id = vcm_->Open(devices_.front().device);
347 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 347 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
348 348
349 // Wait for device opened. 349 // Wait for device opened.
350 base::RunLoop().RunUntilIdle(); 350 base::RunLoop().RunUntilIdle();
351 351
352 vcm_->StopCaptureForClient(controllers_[client_id], client_id, 352 vcm_->StopCaptureForClient(controllers_[client_id], client_id,
353 frame_observer_.get(), true); 353 frame_observer_.get(), true);
354 354
355 // Wait to check callbacks before removing the listener. 355 // Wait to check callbacks before removing the listener.
356 base::RunLoop().RunUntilIdle(); 356 base::RunLoop().RunUntilIdle();
357 vcm_->UnregisterListener(); 357 vcm_->UnregisterListener(listener_.get());
358 } 358 }
359 359
360 TEST_F(VideoCaptureManagerTest, AddObserver) { 360 TEST_F(VideoCaptureManagerTest, AddObserver) {
361 InSequence s; 361 InSequence s;
362 MockVideoCaptureObserver observer; 362 MockVideoCaptureObserver observer;
363 vcm_->AddVideoCaptureObserver(&observer); 363 vcm_->AddVideoCaptureObserver(&observer);
364 364
365 EXPECT_CALL(observer, 365 EXPECT_CALL(observer,
366 OnVideoCaptureStarted(WrappedDeviceFactory::DEFAULT_FACING)); 366 OnVideoCaptureStarted(WrappedDeviceFactory::DEFAULT_FACING));
367 EXPECT_CALL(observer, 367 EXPECT_CALL(observer,
368 OnVideoCaptureStopped(WrappedDeviceFactory::DEFAULT_FACING)); 368 OnVideoCaptureStopped(WrappedDeviceFactory::DEFAULT_FACING));
369 369
370 int video_session_id = vcm_->Open(devices_.front()); 370 int video_session_id = vcm_->Open(devices_.front().device);
371 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 371 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
372 372
373 StopClient(client_id); 373 StopClient(client_id);
374 vcm_->Close(video_session_id); 374 vcm_->Close(video_session_id);
375 375
376 // Wait to check callbacks before removing the listener. 376 // Wait to check callbacks before removing the listener.
377 base::RunLoop().RunUntilIdle(); 377 base::RunLoop().RunUntilIdle();
378 vcm_->UnregisterListener(); 378 vcm_->UnregisterListener(listener_.get());
379 } 379 }
380 380
381 // Open the same device twice. 381 // Open the same device twice.
382 TEST_F(VideoCaptureManagerTest, OpenTwice) { 382 TEST_F(VideoCaptureManagerTest, OpenTwice) {
383 InSequence s; 383 InSequence s;
384 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2); 384 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
385 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2); 385 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
386 386
387 int video_session_id_first = vcm_->Open(devices_.front()); 387 int video_session_id_first = vcm_->Open(devices_.front().device);
388 388
389 // This should trigger an error callback with error code 389 // This should trigger an error callback with error code
390 // 'kDeviceAlreadyInUse'. 390 // 'kDeviceAlreadyInUse'.
391 int video_session_id_second = vcm_->Open(devices_.front()); 391 int video_session_id_second = vcm_->Open(devices_.front().device);
392 EXPECT_NE(video_session_id_first, video_session_id_second); 392 EXPECT_NE(video_session_id_first, video_session_id_second);
393 393
394 vcm_->Close(video_session_id_first); 394 vcm_->Close(video_session_id_first);
395 vcm_->Close(video_session_id_second); 395 vcm_->Close(video_session_id_second);
396 396
397 // Wait to check callbacks before removing the listener. 397 // Wait to check callbacks before removing the listener.
398 base::RunLoop().RunUntilIdle(); 398 base::RunLoop().RunUntilIdle();
399 vcm_->UnregisterListener(); 399 vcm_->UnregisterListener(listener_.get());
400 } 400 }
401 401
402 // Connect and disconnect devices. 402 // Connect and disconnect devices.
403 TEST_F(VideoCaptureManagerTest, ConnectAndDisconnectDevices) { 403 TEST_F(VideoCaptureManagerTest, ConnectAndDisconnectDevices) {
404 int number_of_devices_keep = 404 int number_of_devices_keep =
405 video_capture_device_factory_->number_of_devices(); 405 video_capture_device_factory_->number_of_devices();
406 406
407 // Simulate we remove 1 fake device. 407 // Simulate we remove 1 fake device.
408 video_capture_device_factory_->SetToDefaultDevicesConfig(1); 408 video_capture_device_factory_->SetToDefaultDevicesConfig(1);
409 base::RunLoop run_loop; 409 base::RunLoop run_loop;
410 vcm_->EnumerateDevices( 410 vcm_->EnumerateDevices(
411 base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult, 411 base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult,
412 base::Unretained(this), run_loop.QuitClosure())); 412 base::Unretained(this), run_loop.QuitClosure()));
413 run_loop.Run(); 413 run_loop.Run();
414 ASSERT_EQ(devices_.size(), 1u); 414 ASSERT_EQ(devices_.size(), 1u);
415 415
416 // Simulate we add 2 fake devices. 416 // Simulate we add 2 fake devices.
417 video_capture_device_factory_->SetToDefaultDevicesConfig(3); 417 video_capture_device_factory_->SetToDefaultDevicesConfig(3);
418 base::RunLoop run_loop2; 418 base::RunLoop run_loop2;
419 vcm_->EnumerateDevices( 419 vcm_->EnumerateDevices(
420 base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult, 420 base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult,
421 base::Unretained(this), run_loop2.QuitClosure())); 421 base::Unretained(this), run_loop2.QuitClosure()));
422 run_loop2.Run(); 422 run_loop2.Run();
423 ASSERT_EQ(devices_.size(), 3u); 423 ASSERT_EQ(devices_.size(), 3u);
424 424
425 vcm_->UnregisterListener(); 425 vcm_->UnregisterListener(listener_.get());
426 video_capture_device_factory_->SetToDefaultDevicesConfig( 426 video_capture_device_factory_->SetToDefaultDevicesConfig(
427 number_of_devices_keep); 427 number_of_devices_keep);
428 } 428 }
429 429
430 // Enumerate devices and open the first, then check the list of supported 430 // Enumerate devices and open the first, then check the list of supported
431 // formats. Then start the opened device. The capability list should stay the 431 // formats. Then start the opened device. The capability list should stay the
432 // same. Finally stop the device and check that the capabilities stay unchanged. 432 // same. Finally stop the device and check that the capabilities stay unchanged.
433 TEST_F(VideoCaptureManagerTest, ManipulateDeviceAndCheckCapabilities) { 433 TEST_F(VideoCaptureManagerTest, ManipulateDeviceAndCheckCapabilities) {
434 // Before enumerating the devices, requesting formats should return false. 434 // Before enumerating the devices, requesting formats should return false.
435 int video_session_id = 0; 435 int video_session_id = 0;
436 media::VideoCaptureFormats supported_formats; 436 media::VideoCaptureFormats supported_formats;
437 supported_formats.clear(); 437 supported_formats.clear();
438 EXPECT_FALSE( 438 EXPECT_FALSE(
439 vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats)); 439 vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats));
440 440
441 InSequence s; 441 InSequence s;
442 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 442 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
443 video_session_id = vcm_->Open(devices_.front()); 443 video_session_id = vcm_->Open(devices_.front().device);
444 base::RunLoop().RunUntilIdle(); 444 base::RunLoop().RunUntilIdle();
445 445
446 // Right after opening the device, we should see all its formats. 446 // Right after opening the device, we should see all its formats.
447 supported_formats.clear(); 447 supported_formats.clear();
448 EXPECT_TRUE( 448 EXPECT_TRUE(
449 vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats)); 449 vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats));
450 ASSERT_GT(supported_formats.size(), 1u); 450 ASSERT_GT(supported_formats.size(), 1u);
451 EXPECT_GT(supported_formats[0].frame_size.width(), 1); 451 EXPECT_GT(supported_formats[0].frame_size.width(), 1);
452 EXPECT_GT(supported_formats[0].frame_size.height(), 1); 452 EXPECT_GT(supported_formats[0].frame_size.height(), 1);
453 EXPECT_GT(supported_formats[0].frame_rate, 1); 453 EXPECT_GT(supported_formats[0].frame_rate, 1);
(...skipping 24 matching lines...) Expand all
478 ASSERT_GE(supported_formats.size(), 2u); 478 ASSERT_GE(supported_formats.size(), 2u);
479 EXPECT_GT(supported_formats[0].frame_size.width(), 1); 479 EXPECT_GT(supported_formats[0].frame_size.width(), 1);
480 EXPECT_GT(supported_formats[0].frame_size.height(), 1); 480 EXPECT_GT(supported_formats[0].frame_size.height(), 1);
481 EXPECT_GT(supported_formats[0].frame_rate, 1); 481 EXPECT_GT(supported_formats[0].frame_rate, 1);
482 EXPECT_GT(supported_formats[1].frame_size.width(), 1); 482 EXPECT_GT(supported_formats[1].frame_size.width(), 1);
483 EXPECT_GT(supported_formats[1].frame_size.height(), 1); 483 EXPECT_GT(supported_formats[1].frame_size.height(), 1);
484 EXPECT_GT(supported_formats[1].frame_rate, 1); 484 EXPECT_GT(supported_formats[1].frame_rate, 1);
485 485
486 vcm_->Close(video_session_id); 486 vcm_->Close(video_session_id);
487 base::RunLoop().RunUntilIdle(); 487 base::RunLoop().RunUntilIdle();
488 vcm_->UnregisterListener(); 488 vcm_->UnregisterListener(listener_.get());
489 } 489 }
490 490
491 // Enumerate devices, then check the list of supported formats. Then open and 491 // Enumerate devices, then check the list of supported formats. Then open and
492 // start the first device. The capability list should stay the same. Finally 492 // start the first device. The capability list should stay the same. Finally
493 // stop the device and check that the capabilities stay unchanged. 493 // stop the device and check that the capabilities stay unchanged.
494 TEST_F(VideoCaptureManagerTest, 494 TEST_F(VideoCaptureManagerTest,
495 ManipulateDeviceAndCheckCapabilitiesWithDeviceId) { 495 ManipulateDeviceAndCheckCapabilitiesWithDeviceId) {
496 // Requesting formats should work even before enumerating/opening devices. 496 // Requesting formats should work even before enumerating/opening devices.
497 std::string device_id = devices_.front().device.id; 497 std::string device_id = devices_.front().device.id;
498 media::VideoCaptureFormats supported_formats; 498 media::VideoCaptureFormats supported_formats;
499 supported_formats.clear(); 499 supported_formats.clear();
500 EXPECT_TRUE(vcm_->GetDeviceSupportedFormats(device_id, &supported_formats)); 500 EXPECT_TRUE(vcm_->GetDeviceSupportedFormats(device_id, &supported_formats));
501 ASSERT_GE(supported_formats.size(), 2u); 501 ASSERT_GE(supported_formats.size(), 2u);
502 EXPECT_GT(supported_formats[0].frame_size.width(), 1); 502 EXPECT_GT(supported_formats[0].frame_size.width(), 1);
503 EXPECT_GT(supported_formats[0].frame_size.height(), 1); 503 EXPECT_GT(supported_formats[0].frame_size.height(), 1);
504 EXPECT_GT(supported_formats[0].frame_rate, 1); 504 EXPECT_GT(supported_formats[0].frame_rate, 1);
505 EXPECT_GT(supported_formats[1].frame_size.width(), 1); 505 EXPECT_GT(supported_formats[1].frame_size.width(), 1);
506 EXPECT_GT(supported_formats[1].frame_size.height(), 1); 506 EXPECT_GT(supported_formats[1].frame_size.height(), 1);
507 EXPECT_GT(supported_formats[1].frame_rate, 1); 507 EXPECT_GT(supported_formats[1].frame_rate, 1);
508 508
509 InSequence s; 509 InSequence s;
510 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 510 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
511 int video_session_id = vcm_->Open(devices_.front()); 511 int video_session_id = vcm_->Open(devices_.front().device);
512 base::RunLoop().RunUntilIdle(); 512 base::RunLoop().RunUntilIdle();
513 513
514 // Right after opening the device, we should see all its formats. 514 // Right after opening the device, we should see all its formats.
515 supported_formats.clear(); 515 supported_formats.clear();
516 EXPECT_TRUE(vcm_->GetDeviceSupportedFormats(device_id, &supported_formats)); 516 EXPECT_TRUE(vcm_->GetDeviceSupportedFormats(device_id, &supported_formats));
517 ASSERT_GE(supported_formats.size(), 2u); 517 ASSERT_GE(supported_formats.size(), 2u);
518 EXPECT_GT(supported_formats[0].frame_size.width(), 1); 518 EXPECT_GT(supported_formats[0].frame_size.width(), 1);
519 EXPECT_GT(supported_formats[0].frame_size.height(), 1); 519 EXPECT_GT(supported_formats[0].frame_size.height(), 1);
520 EXPECT_GT(supported_formats[0].frame_rate, 1); 520 EXPECT_GT(supported_formats[0].frame_rate, 1);
521 EXPECT_GT(supported_formats[1].frame_size.width(), 1); 521 EXPECT_GT(supported_formats[1].frame_size.width(), 1);
(...skipping 21 matching lines...) Expand all
543 ASSERT_GE(supported_formats.size(), 2u); 543 ASSERT_GE(supported_formats.size(), 2u);
544 EXPECT_GT(supported_formats[0].frame_size.width(), 1); 544 EXPECT_GT(supported_formats[0].frame_size.width(), 1);
545 EXPECT_GT(supported_formats[0].frame_size.height(), 1); 545 EXPECT_GT(supported_formats[0].frame_size.height(), 1);
546 EXPECT_GT(supported_formats[0].frame_rate, 1); 546 EXPECT_GT(supported_formats[0].frame_rate, 1);
547 EXPECT_GT(supported_formats[1].frame_size.width(), 1); 547 EXPECT_GT(supported_formats[1].frame_size.width(), 1);
548 EXPECT_GT(supported_formats[1].frame_size.height(), 1); 548 EXPECT_GT(supported_formats[1].frame_size.height(), 1);
549 EXPECT_GT(supported_formats[1].frame_rate, 1); 549 EXPECT_GT(supported_formats[1].frame_rate, 1);
550 550
551 vcm_->Close(video_session_id); 551 vcm_->Close(video_session_id);
552 base::RunLoop().RunUntilIdle(); 552 base::RunLoop().RunUntilIdle();
553 vcm_->UnregisterListener(); 553 vcm_->UnregisterListener(listener_.get());
554 } 554 }
555 555
556 // Enumerate devices and open the first, then check the formats currently in 556 // Enumerate devices and open the first, then check the formats currently in
557 // use, which should be an empty vector. Then start the opened device. The 557 // use, which should be an empty vector. Then start the opened device. The
558 // format(s) in use should be just one format (the one used when configuring- 558 // format(s) in use should be just one format (the one used when configuring-
559 // starting the device). Finally stop the device and check that the formats in 559 // starting the device). Finally stop the device and check that the formats in
560 // use is an empty vector. 560 // use is an empty vector.
561 TEST_F(VideoCaptureManagerTest, StartDeviceAndGetDeviceFormatInUse) { 561 TEST_F(VideoCaptureManagerTest, StartDeviceAndGetDeviceFormatInUse) {
562 InSequence s; 562 InSequence s;
563 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 563 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
564 int video_session_id = vcm_->Open(devices_.front()); 564 int video_session_id = vcm_->Open(devices_.front().device);
565 base::RunLoop().RunUntilIdle(); 565 base::RunLoop().RunUntilIdle();
566 566
567 // Right after opening the device, we should see no format in use. 567 // Right after opening the device, we should see no format in use.
568 media::VideoCaptureFormats formats_in_use; 568 media::VideoCaptureFormats formats_in_use;
569 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use)); 569 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use));
570 EXPECT_TRUE(formats_in_use.empty()); 570 EXPECT_TRUE(formats_in_use.empty());
571 571
572 EXPECT_CALL(*frame_observer_, OnStarted(_)); 572 EXPECT_CALL(*frame_observer_, OnStarted(_));
573 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 573 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
574 base::RunLoop().RunUntilIdle(); 574 base::RunLoop().RunUntilIdle();
(...skipping 11 matching lines...) Expand all
586 586
587 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 587 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
588 StopClient(client_id); 588 StopClient(client_id);
589 base::RunLoop().RunUntilIdle(); 589 base::RunLoop().RunUntilIdle();
590 // After StopClient(), the device's formats in use should be empty again. 590 // After StopClient(), the device's formats in use should be empty again.
591 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use)); 591 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use));
592 EXPECT_TRUE(formats_in_use.empty()); 592 EXPECT_TRUE(formats_in_use.empty());
593 593
594 vcm_->Close(video_session_id); 594 vcm_->Close(video_session_id);
595 base::RunLoop().RunUntilIdle(); 595 base::RunLoop().RunUntilIdle();
596 vcm_->UnregisterListener(); 596 vcm_->UnregisterListener(listener_.get());
597 } 597 }
598 598
599 // Enumerate devices and open the first, then check the formats currently in 599 // Enumerate devices and open the first, then check the formats currently in
600 // use, which should be an empty vector. Then start the opened device. The 600 // use, which should be an empty vector. Then start the opened device. The
601 // format(s) in use should be just one format (the one used when configuring- 601 // format(s) in use should be just one format (the one used when configuring-
602 // starting the device). Finally stop the device and check that the formats in 602 // starting the device). Finally stop the device and check that the formats in
603 // use is an empty vector. 603 // use is an empty vector.
604 TEST_F(VideoCaptureManagerTest, 604 TEST_F(VideoCaptureManagerTest,
605 StartDeviceAndGetDeviceFormatInUseWithDeviceId) { 605 StartDeviceAndGetDeviceFormatInUseWithDeviceId) {
606 std::string device_id = devices_.front().device.id; 606 std::string device_id = devices_.front().device.id;
607 InSequence s; 607 InSequence s;
608 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 608 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
609 int video_session_id = vcm_->Open(devices_.front()); 609 int video_session_id = vcm_->Open(devices_.front().device);
610 base::RunLoop().RunUntilIdle(); 610 base::RunLoop().RunUntilIdle();
611 611
612 // Right after opening the device, we should see no format in use. 612 // Right after opening the device, we should see no format in use.
613 media::VideoCaptureFormats formats_in_use; 613 media::VideoCaptureFormats formats_in_use;
614 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id, 614 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id,
615 &formats_in_use)); 615 &formats_in_use));
616 EXPECT_TRUE(formats_in_use.empty()); 616 EXPECT_TRUE(formats_in_use.empty());
617 617
618 EXPECT_CALL(*frame_observer_, OnStarted(_)); 618 EXPECT_CALL(*frame_observer_, OnStarted(_));
619 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 619 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
(...skipping 14 matching lines...) Expand all
634 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 634 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
635 StopClient(client_id); 635 StopClient(client_id);
636 base::RunLoop().RunUntilIdle(); 636 base::RunLoop().RunUntilIdle();
637 // After StopClient(), the device's formats in use should be empty again. 637 // After StopClient(), the device's formats in use should be empty again.
638 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id, 638 EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id,
639 &formats_in_use)); 639 &formats_in_use));
640 EXPECT_TRUE(formats_in_use.empty()); 640 EXPECT_TRUE(formats_in_use.empty());
641 641
642 vcm_->Close(video_session_id); 642 vcm_->Close(video_session_id);
643 base::RunLoop().RunUntilIdle(); 643 base::RunLoop().RunUntilIdle();
644 vcm_->UnregisterListener(); 644 vcm_->UnregisterListener(listener_.get());
645 } 645 }
646 646
647 // Open two different devices. 647 // Open two different devices.
648 TEST_F(VideoCaptureManagerTest, OpenTwo) { 648 TEST_F(VideoCaptureManagerTest, OpenTwo) {
649 InSequence s; 649 InSequence s;
650 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2); 650 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
651 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2); 651 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
652 652
653 StreamDeviceInfoArray::iterator it = devices_.begin(); 653 StreamDeviceInfoArray::iterator it = devices_.begin();
654 654
655 int video_session_id_first = vcm_->Open(*it); 655 int video_session_id_first = vcm_->Open(it->device);
656 ++it; 656 ++it;
657 int video_session_id_second = vcm_->Open(*it); 657 int video_session_id_second = vcm_->Open(it->device);
658 658
659 vcm_->Close(video_session_id_first); 659 vcm_->Close(video_session_id_first);
660 vcm_->Close(video_session_id_second); 660 vcm_->Close(video_session_id_second);
661 661
662 // Wait to check callbacks before removing the listener. 662 // Wait to check callbacks before removing the listener.
663 base::RunLoop().RunUntilIdle(); 663 base::RunLoop().RunUntilIdle();
664 vcm_->UnregisterListener(); 664 vcm_->UnregisterListener(listener_.get());
665 } 665 }
666 666
667 // Try open a non-existing device. 667 // Try open a non-existing device.
668 TEST_F(VideoCaptureManagerTest, OpenNotExisting) { 668 TEST_F(VideoCaptureManagerTest, OpenNotExisting) {
669 InSequence s; 669 InSequence s;
670 EXPECT_CALL(*frame_observer_, OnError(_)); 670 EXPECT_CALL(*frame_observer_, OnError(_));
671 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 671 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
672 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 672 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
673 673
674 MediaStreamType stream_type = MEDIA_DEVICE_VIDEO_CAPTURE; 674 MediaStreamType stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
675 std::string device_name("device_doesnt_exist"); 675 std::string device_name("device_doesnt_exist");
676 std::string device_id("id_doesnt_exist"); 676 std::string device_id("id_doesnt_exist");
677 StreamDeviceInfo dummy_device(stream_type, device_name, device_id); 677 MediaStreamDevice dummy_device(stream_type, device_id, device_name);
678 678
679 // This should fail with an error to the controller. 679 // This should fail with an error to the controller.
680 int session_id = vcm_->Open(dummy_device); 680 int session_id = vcm_->Open(dummy_device);
681 VideoCaptureControllerID client_id = StartClient(session_id, true); 681 VideoCaptureControllerID client_id = StartClient(session_id, true);
682 base::RunLoop().RunUntilIdle(); 682 base::RunLoop().RunUntilIdle();
683 683
684 StopClient(client_id); 684 StopClient(client_id);
685 vcm_->Close(session_id); 685 vcm_->Close(session_id);
686 base::RunLoop().RunUntilIdle(); 686 base::RunLoop().RunUntilIdle();
687 687
688 vcm_->UnregisterListener(); 688 vcm_->UnregisterListener(listener_.get());
689 } 689 }
690 690
691 // Start a device without calling Open, using a non-magic ID. 691 // Start a device without calling Open, using a non-magic ID.
692 TEST_F(VideoCaptureManagerTest, StartInvalidSession) { 692 TEST_F(VideoCaptureManagerTest, StartInvalidSession) {
693 StartClient(22, false); 693 StartClient(22, false);
694 694
695 // Wait to check callbacks before removing the listener. 695 // Wait to check callbacks before removing the listener.
696 base::RunLoop().RunUntilIdle(); 696 base::RunLoop().RunUntilIdle();
697 vcm_->UnregisterListener(); 697 vcm_->UnregisterListener(listener_.get());
698 } 698 }
699 699
700 // Open and start a device, close it before calling Stop. 700 // Open and start a device, close it before calling Stop.
701 TEST_F(VideoCaptureManagerTest, CloseWithoutStop) { 701 TEST_F(VideoCaptureManagerTest, CloseWithoutStop) {
702 InSequence s; 702 InSequence s;
703 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 703 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
704 EXPECT_CALL(*frame_observer_, OnStarted(_)); 704 EXPECT_CALL(*frame_observer_, OnStarted(_));
705 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 705 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
706 706
707 int video_session_id = vcm_->Open(devices_.front()); 707 int video_session_id = vcm_->Open(devices_.front().device);
708 708
709 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 709 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
710 710
711 // Close will stop the running device, an assert will be triggered in 711 // Close will stop the running device, an assert will be triggered in
712 // VideoCaptureManager destructor otherwise. 712 // VideoCaptureManager destructor otherwise.
713 vcm_->Close(video_session_id); 713 vcm_->Close(video_session_id);
714 StopClient(client_id); 714 StopClient(client_id);
715 715
716 // Wait to check callbacks before removing the listener 716 // Wait to check callbacks before removing the listener
717 base::RunLoop().RunUntilIdle(); 717 base::RunLoop().RunUntilIdle();
718 vcm_->UnregisterListener(); 718 vcm_->UnregisterListener(listener_.get());
719 } 719 }
720 720
721 // Try to open, start, pause and resume a device. Confirm the device is 721 // Try to open, start, pause and resume a device. Confirm the device is
722 // paused/resumed at the correct times in both single-client and multiple-client 722 // paused/resumed at the correct times in both single-client and multiple-client
723 // scenarios. 723 // scenarios.
724 TEST_F(VideoCaptureManagerTest, PauseAndResumeClient) { 724 TEST_F(VideoCaptureManagerTest, PauseAndResumeClient) {
725 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 725 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
726 EXPECT_CALL(*frame_observer_, OnStarted(_)); 726 EXPECT_CALL(*frame_observer_, OnStarted(_));
727 727
728 const int video_session_id = vcm_->Open(devices_.front()); 728 const int video_session_id = vcm_->Open(devices_.front().device);
729 const VideoCaptureControllerID client_id = 729 const VideoCaptureControllerID client_id =
730 StartClient(video_session_id, true); 730 StartClient(video_session_id, true);
731 731
732 // Test pause/resume when only one client is present. 732 // Test pause/resume when only one client is present.
733 EXPECT_CALL(*video_capture_device_factory_, WillSuspendDevice()).Times(1); 733 EXPECT_CALL(*video_capture_device_factory_, WillSuspendDevice()).Times(1);
734 PauseClient(client_id); 734 PauseClient(client_id);
735 EXPECT_CALL(*video_capture_device_factory_, WillResumeDevice()).Times(1); 735 EXPECT_CALL(*video_capture_device_factory_, WillResumeDevice()).Times(1);
736 ResumeClient(video_session_id, client_id); 736 ResumeClient(video_session_id, client_id);
737 737
738 // Attempting to resume the client a second time should not cause any calls to 738 // Attempting to resume the client a second time should not cause any calls to
739 // VideoCaptureDevice::Resume(). 739 // VideoCaptureDevice::Resume().
740 ResumeClient(video_session_id, client_id); 740 ResumeClient(video_session_id, client_id);
741 741
742 // Add a second client that is never paused, then pause/resume the first 742 // Add a second client that is never paused, then pause/resume the first
743 // client, and no calls to VideoCaptureDevice::MaybeSuspend() or Resume() are 743 // client, and no calls to VideoCaptureDevice::MaybeSuspend() or Resume() are
744 // made. 744 // made.
745 const VideoCaptureControllerID client_id2 = 745 const VideoCaptureControllerID client_id2 =
746 StartClient(video_session_id, true); 746 StartClient(video_session_id, true);
747 PauseClient(client_id); 747 PauseClient(client_id);
748 ResumeClient(video_session_id, client_id); 748 ResumeClient(video_session_id, client_id);
749 749
750 StopClient(client_id); 750 StopClient(client_id);
751 StopClient(client_id2); 751 StopClient(client_id2);
752 752
753 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 753 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
754 vcm_->Close(video_session_id); 754 vcm_->Close(video_session_id);
755 755
756 // Wait to check callbacks before removing the listener. 756 // Wait to check callbacks before removing the listener.
757 base::RunLoop().RunUntilIdle(); 757 base::RunLoop().RunUntilIdle();
758 vcm_->UnregisterListener(); 758 vcm_->UnregisterListener(listener_.get());
759 } 759 }
760 760
761 #if defined(OS_ANDROID) 761 #if defined(OS_ANDROID)
762 // Try to open, start, pause and resume a device. 762 // Try to open, start, pause and resume a device.
763 TEST_F(VideoCaptureManagerTest, PauseAndResumeDevice) { 763 TEST_F(VideoCaptureManagerTest, PauseAndResumeDevice) {
764 InSequence s; 764 InSequence s;
765 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 765 EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
766 EXPECT_CALL(*frame_observer_, OnStarted(_)); 766 EXPECT_CALL(*frame_observer_, OnStarted(_));
767 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)); 767 EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
768 768
769 int video_session_id = vcm_->Open(devices_.front()); 769 int video_session_id = vcm_->Open(devices_.front().device);
770 VideoCaptureControllerID client_id = StartClient(video_session_id, true); 770 VideoCaptureControllerID client_id = StartClient(video_session_id, true);
771 771
772 // Release/ResumeDevices according to ApplicationStatus. Should cause no 772 // Release/ResumeDevices according to ApplicationStatus. Should cause no
773 // problem in any order. Check https://crbug.com/615557 for more details. 773 // problem in any order. Check https://crbug.com/615557 for more details.
774 ApplicationStateChange( 774 ApplicationStateChange(
775 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); 775 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
776 ApplicationStateChange( 776 ApplicationStateChange(
777 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES); 777 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
778 ApplicationStateChange( 778 ApplicationStateChange(
779 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES); 779 base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
780 ApplicationStateChange( 780 ApplicationStateChange(
781 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); 781 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
782 ApplicationStateChange( 782 ApplicationStateChange(
783 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES); 783 base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
784 784
785 StopClient(client_id); 785 StopClient(client_id);
786 vcm_->Close(video_session_id); 786 vcm_->Close(video_session_id);
787 787
788 // Wait to check callbacks before removing the listener. 788 // Wait to check callbacks before removing the listener.
789 base::RunLoop().RunUntilIdle(); 789 base::RunLoop().RunUntilIdle();
790 vcm_->UnregisterListener(); 790 vcm_->UnregisterListener(listener_.get());
791 } 791 }
792 #endif 792 #endif
793 793
794 // TODO(mcasas): Add a test to check consolidation of the supported formats 794 // TODO(mcasas): Add a test to check consolidation of the supported formats
795 // provided by the device when http://crbug.com/323913 is closed. 795 // provided by the device when http://crbug.com/323913 is closed.
796 796
797 } // namespace content 797 } // namespace content
OLDNEW
« no previous file with comments | « content/browser/renderer_host/media/video_capture_manager.cc ('k') | content/test/BUILD.gn » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698