EME: Require codecs parameter for audio/videoCapabilities

media/blink/key_system_config_selector_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 615 matching lines @@
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kUnsupportedContainer;
   video_capabilities[1].contentType = "b";
   video_capabilities[1].mimeType = kSupportedVideoContainer;
+  video_capabilities[1].codecs = kSupportedVideoCodec;

[xhwang, 2017/02/09 20:07:55]

Can we add a test where everything in the capabilities are legit but the codecs
is missing? That capabilities should be supported without this CL, but not
supported now.

[jrummell, 2017/02/09 23:36:08]

Done.

 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_EQ("b", config_.videoCapabilities[0].contentType);
   EXPECT_EQ(kSupportedVideoContainer, config_.videoCapabilities[0].mimeType);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_AllSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodecs;
   video_capabilities[1].contentType = "b";
   video_capabilities[1].mimeType = kSupportedVideoContainer;
   video_capabilities[1].codecs = kSupportedVideoCodecs;
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(2u, config_.videoCapabilities.size());
@@ skipping 27 matching lines @@
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_EQ(kSupportedVideoCodecs, config_.videoCapabilities[0].codecs);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Empty) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodec;
   ASSERT_TRUE(video_capabilities[0].robustness.isEmpty());
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_TRUE(config_.videoCapabilities[0].robustness.isEmpty());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Supported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodec;
   video_capabilities[0].robustness = kSupported;
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
   EXPECT_EQ(kSupported, config_.videoCapabilities[0].robustness);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Unsupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodec;
   video_capabilities[0].robustness = kUnsupported;
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        VideoCapabilities_Robustness_PermissionCanBeRequired) {
   media_permission_->is_granted = true;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodec;
   video_capabilities[0].robustness = kRequireIdentifier;
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.distinctiveIdentifier);
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        VideoCapabilities_Robustness_PermissionCanBeRecommended) {
   media_permission_->is_granted = false;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodec;
   video_capabilities[0].robustness = kRecommendIdentifier;
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.distinctiveIdentifier);
 }
 
 // --- audioCapabilities ---
 // These are handled by the same code as |videoCapabilities|, so only minimal
 // additional testing is done.
 
 TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(2);
   audio_capabilities[0].contentType = "a";
   audio_capabilities[0].mimeType = kUnsupportedContainer;
   audio_capabilities[1].contentType = "b";
   audio_capabilities[1].mimeType = kSupportedAudioContainer;
+  audio_capabilities[1].codecs = kSupportedAudioCodec;
 
   blink::WebMediaKeySystemConfiguration config = EmptyConfiguration();
   config.audioCapabilities = audio_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.audioCapabilities.size());
   EXPECT_EQ("b", config_.audioCapabilities[0].contentType);
   EXPECT_EQ(kSupportedAudioContainer, config_.audioCapabilities[0].mimeType);
 }
@@ skipping 59 matching lines @@
 
   blink::WebMediaKeySystemConfiguration config2 = UsableConfiguration();
   config2.label = "b";
   configs_.push_back(config2);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   ASSERT_EQ("b", config_.label);
 }
 
 }  // namespace media