OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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 <string> | 5 #include <string> |
6 #include <vector> | 6 #include <vector> |
7 | 7 |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/macros.h" | 9 #include "base/macros.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
(...skipping 615 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
626 | 626 |
627 ASSERT_TRUE(SelectConfigReturnsError()); | 627 ASSERT_TRUE(SelectConfigReturnsError()); |
628 } | 628 } |
629 | 629 |
630 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) { | 630 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) { |
631 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2); | 631 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2); |
632 video_capabilities[0].contentType = "a"; | 632 video_capabilities[0].contentType = "a"; |
633 video_capabilities[0].mimeType = kUnsupportedContainer; | 633 video_capabilities[0].mimeType = kUnsupportedContainer; |
634 video_capabilities[1].contentType = "b"; | 634 video_capabilities[1].contentType = "b"; |
635 video_capabilities[1].mimeType = kSupportedVideoContainer; | 635 video_capabilities[1].mimeType = kSupportedVideoContainer; |
| 636 video_capabilities[1].codecs = kSupportedVideoCodec; |
636 | 637 |
637 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 638 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
638 config.videoCapabilities = video_capabilities; | 639 config.videoCapabilities = video_capabilities; |
639 configs_.push_back(config); | 640 configs_.push_back(config); |
640 | 641 |
641 ASSERT_TRUE(SelectConfigReturnsConfig()); | 642 ASSERT_TRUE(SelectConfigReturnsConfig()); |
642 ASSERT_EQ(1u, config_.videoCapabilities.size()); | 643 ASSERT_EQ(1u, config_.videoCapabilities.size()); |
643 EXPECT_EQ("b", config_.videoCapabilities[0].contentType); | 644 EXPECT_EQ("b", config_.videoCapabilities[0].contentType); |
644 EXPECT_EQ(kSupportedVideoContainer, config_.videoCapabilities[0].mimeType); | 645 EXPECT_EQ(kSupportedVideoContainer, config_.videoCapabilities[0].mimeType); |
645 } | 646 } |
646 | 647 |
647 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_AllSupported) { | 648 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_AllSupported) { |
648 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2); | 649 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2); |
649 video_capabilities[0].contentType = "a"; | 650 video_capabilities[0].contentType = "a"; |
650 video_capabilities[0].mimeType = kSupportedVideoContainer; | 651 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 652 video_capabilities[0].codecs = kSupportedVideoCodecs; |
651 video_capabilities[1].contentType = "b"; | 653 video_capabilities[1].contentType = "b"; |
652 video_capabilities[1].mimeType = kSupportedVideoContainer; | 654 video_capabilities[1].mimeType = kSupportedVideoContainer; |
653 video_capabilities[1].codecs = kSupportedVideoCodecs; | 655 video_capabilities[1].codecs = kSupportedVideoCodecs; |
654 | 656 |
655 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 657 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
656 config.videoCapabilities = video_capabilities; | 658 config.videoCapabilities = video_capabilities; |
657 configs_.push_back(config); | 659 configs_.push_back(config); |
658 | 660 |
659 ASSERT_TRUE(SelectConfigReturnsConfig()); | 661 ASSERT_TRUE(SelectConfigReturnsConfig()); |
660 ASSERT_EQ(2u, config_.videoCapabilities.size()); | 662 ASSERT_EQ(2u, config_.videoCapabilities.size()); |
(...skipping 23 matching lines...) Expand all Loading... |
684 | 686 |
685 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 687 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
686 config.videoCapabilities = video_capabilities; | 688 config.videoCapabilities = video_capabilities; |
687 configs_.push_back(config); | 689 configs_.push_back(config); |
688 | 690 |
689 ASSERT_TRUE(SelectConfigReturnsConfig()); | 691 ASSERT_TRUE(SelectConfigReturnsConfig()); |
690 ASSERT_EQ(1u, config_.videoCapabilities.size()); | 692 ASSERT_EQ(1u, config_.videoCapabilities.size()); |
691 EXPECT_EQ(kSupportedVideoCodecs, config_.videoCapabilities[0].codecs); | 693 EXPECT_EQ(kSupportedVideoCodecs, config_.videoCapabilities[0].codecs); |
692 } | 694 } |
693 | 695 |
| 696 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Missing_Codecs) { |
| 697 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); |
| 698 video_capabilities[0].contentType = "a"; |
| 699 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 700 |
| 701 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
| 702 config.videoCapabilities = video_capabilities; |
| 703 configs_.push_back(config); |
| 704 |
| 705 ASSERT_TRUE(SelectConfigReturnsError()); |
| 706 } |
| 707 |
694 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Empty) { | 708 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Empty) { |
695 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); | 709 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); |
696 video_capabilities[0].contentType = "a"; | 710 video_capabilities[0].contentType = "a"; |
697 video_capabilities[0].mimeType = kSupportedVideoContainer; | 711 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 712 video_capabilities[0].codecs = kSupportedVideoCodec; |
698 ASSERT_TRUE(video_capabilities[0].robustness.isEmpty()); | 713 ASSERT_TRUE(video_capabilities[0].robustness.isEmpty()); |
699 | 714 |
700 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 715 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
701 config.videoCapabilities = video_capabilities; | 716 config.videoCapabilities = video_capabilities; |
702 configs_.push_back(config); | 717 configs_.push_back(config); |
703 | 718 |
704 ASSERT_TRUE(SelectConfigReturnsConfig()); | 719 ASSERT_TRUE(SelectConfigReturnsConfig()); |
705 ASSERT_EQ(1u, config_.videoCapabilities.size()); | 720 ASSERT_EQ(1u, config_.videoCapabilities.size()); |
706 EXPECT_TRUE(config_.videoCapabilities[0].robustness.isEmpty()); | 721 EXPECT_TRUE(config_.videoCapabilities[0].robustness.isEmpty()); |
707 } | 722 } |
708 | 723 |
709 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Supported) { | 724 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Supported) { |
710 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); | 725 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); |
711 video_capabilities[0].contentType = "a"; | 726 video_capabilities[0].contentType = "a"; |
712 video_capabilities[0].mimeType = kSupportedVideoContainer; | 727 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 728 video_capabilities[0].codecs = kSupportedVideoCodec; |
713 video_capabilities[0].robustness = kSupported; | 729 video_capabilities[0].robustness = kSupported; |
714 | 730 |
715 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 731 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
716 config.videoCapabilities = video_capabilities; | 732 config.videoCapabilities = video_capabilities; |
717 configs_.push_back(config); | 733 configs_.push_back(config); |
718 | 734 |
719 ASSERT_TRUE(SelectConfigReturnsConfig()); | 735 ASSERT_TRUE(SelectConfigReturnsConfig()); |
720 ASSERT_EQ(1u, config_.videoCapabilities.size()); | 736 ASSERT_EQ(1u, config_.videoCapabilities.size()); |
721 EXPECT_EQ(kSupported, config_.videoCapabilities[0].robustness); | 737 EXPECT_EQ(kSupported, config_.videoCapabilities[0].robustness); |
722 } | 738 } |
723 | 739 |
724 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Unsupported) { | 740 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Unsupported) { |
725 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); | 741 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); |
726 video_capabilities[0].contentType = "a"; | 742 video_capabilities[0].contentType = "a"; |
727 video_capabilities[0].mimeType = kSupportedVideoContainer; | 743 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 744 video_capabilities[0].codecs = kSupportedVideoCodec; |
728 video_capabilities[0].robustness = kUnsupported; | 745 video_capabilities[0].robustness = kUnsupported; |
729 | 746 |
730 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 747 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
731 config.videoCapabilities = video_capabilities; | 748 config.videoCapabilities = video_capabilities; |
732 configs_.push_back(config); | 749 configs_.push_back(config); |
733 | 750 |
734 ASSERT_TRUE(SelectConfigReturnsError()); | 751 ASSERT_TRUE(SelectConfigReturnsError()); |
735 } | 752 } |
736 | 753 |
737 TEST_F(KeySystemConfigSelectorTest, | 754 TEST_F(KeySystemConfigSelectorTest, |
738 VideoCapabilities_Robustness_PermissionCanBeRequired) { | 755 VideoCapabilities_Robustness_PermissionCanBeRequired) { |
739 media_permission_->is_granted = true; | 756 media_permission_->is_granted = true; |
740 key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE; | 757 key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE; |
741 | 758 |
742 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); | 759 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); |
743 video_capabilities[0].contentType = "a"; | 760 video_capabilities[0].contentType = "a"; |
744 video_capabilities[0].mimeType = kSupportedVideoContainer; | 761 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 762 video_capabilities[0].codecs = kSupportedVideoCodec; |
745 video_capabilities[0].robustness = kRequireIdentifier; | 763 video_capabilities[0].robustness = kRequireIdentifier; |
746 | 764 |
747 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 765 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
748 config.videoCapabilities = video_capabilities; | 766 config.videoCapabilities = video_capabilities; |
749 configs_.push_back(config); | 767 configs_.push_back(config); |
750 | 768 |
751 ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig()); | 769 ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig()); |
752 EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required, | 770 EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required, |
753 config_.distinctiveIdentifier); | 771 config_.distinctiveIdentifier); |
754 } | 772 } |
755 | 773 |
756 TEST_F(KeySystemConfigSelectorTest, | 774 TEST_F(KeySystemConfigSelectorTest, |
757 VideoCapabilities_Robustness_PermissionCanBeRecommended) { | 775 VideoCapabilities_Robustness_PermissionCanBeRecommended) { |
758 media_permission_->is_granted = false; | 776 media_permission_->is_granted = false; |
759 key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE; | 777 key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE; |
760 | 778 |
761 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); | 779 std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1); |
762 video_capabilities[0].contentType = "a"; | 780 video_capabilities[0].contentType = "a"; |
763 video_capabilities[0].mimeType = kSupportedVideoContainer; | 781 video_capabilities[0].mimeType = kSupportedVideoContainer; |
| 782 video_capabilities[0].codecs = kSupportedVideoCodec; |
764 video_capabilities[0].robustness = kRecommendIdentifier; | 783 video_capabilities[0].robustness = kRecommendIdentifier; |
765 | 784 |
766 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 785 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
767 config.videoCapabilities = video_capabilities; | 786 config.videoCapabilities = video_capabilities; |
768 configs_.push_back(config); | 787 configs_.push_back(config); |
769 | 788 |
770 ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig()); | 789 ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig()); |
771 EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed, | 790 EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed, |
772 config_.distinctiveIdentifier); | 791 config_.distinctiveIdentifier); |
773 } | 792 } |
774 | 793 |
775 // --- audioCapabilities --- | 794 // --- audioCapabilities --- |
776 // These are handled by the same code as |videoCapabilities|, so only minimal | 795 // These are handled by the same code as |videoCapabilities|, so only minimal |
777 // additional testing is done. | 796 // additional testing is done. |
778 | 797 |
779 TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) { | 798 TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) { |
780 std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(2); | 799 std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(2); |
781 audio_capabilities[0].contentType = "a"; | 800 audio_capabilities[0].contentType = "a"; |
782 audio_capabilities[0].mimeType = kUnsupportedContainer; | 801 audio_capabilities[0].mimeType = kUnsupportedContainer; |
783 audio_capabilities[1].contentType = "b"; | 802 audio_capabilities[1].contentType = "b"; |
784 audio_capabilities[1].mimeType = kSupportedAudioContainer; | 803 audio_capabilities[1].mimeType = kSupportedAudioContainer; |
| 804 audio_capabilities[1].codecs = kSupportedAudioCodec; |
785 | 805 |
786 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); | 806 blink::WebMediaKeySystemConfiguration config = EmptyConfiguration(); |
787 config.audioCapabilities = audio_capabilities; | 807 config.audioCapabilities = audio_capabilities; |
788 configs_.push_back(config); | 808 configs_.push_back(config); |
789 | 809 |
790 ASSERT_TRUE(SelectConfigReturnsConfig()); | 810 ASSERT_TRUE(SelectConfigReturnsConfig()); |
791 ASSERT_EQ(1u, config_.audioCapabilities.size()); | 811 ASSERT_EQ(1u, config_.audioCapabilities.size()); |
792 EXPECT_EQ("b", config_.audioCapabilities[0].contentType); | 812 EXPECT_EQ("b", config_.audioCapabilities[0].contentType); |
793 EXPECT_EQ(kSupportedAudioContainer, config_.audioCapabilities[0].mimeType); | 813 EXPECT_EQ(kSupportedAudioContainer, config_.audioCapabilities[0].mimeType); |
794 } | 814 } |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
854 | 874 |
855 blink::WebMediaKeySystemConfiguration config2 = UsableConfiguration(); | 875 blink::WebMediaKeySystemConfiguration config2 = UsableConfiguration(); |
856 config2.label = "b"; | 876 config2.label = "b"; |
857 configs_.push_back(config2); | 877 configs_.push_back(config2); |
858 | 878 |
859 ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig()); | 879 ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig()); |
860 ASSERT_EQ("b", config_.label); | 880 ASSERT_EQ("b", config_.label); |
861 } | 881 } |
862 | 882 |
863 } // namespace media | 883 } // namespace media |
OLD | NEW |