EME: Fail requestMediaKeySystemAccess if no capabilities specified

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 11 matching lines @@
 
 namespace media {
 
 namespace {
 
 const char kSupported[] = "supported";
 const char kRecommendIdentifier[] = "recommend_identifier";
 const char kRequireIdentifier[] = "require_identifier";
 const char kUnsupported[] = "unsupported";
 
-// TODO(sandersd): Audio and video variants (doesn't matter for now because the
-// checks are in KeySystems).
-const char kSupportedContainer[] = "video/webm";
+const char kSupportedVideoContainer[] = "video/webm";
+const char kSupportedAudioContainer[] = "audio/webm";
 const char kUnsupportedContainer[] = "video/foo";
 
 // TODO(sandersd): Extended codec variants (requires proprietary codec support).
-const char kSupportedCodec[] = "vp8";
+const char kSupportedVideoCodec[] = "vp8";
+const char kSupportedAudioCodec[] = "opus";
 const char kUnsupportedCodec[] = "foo";
 const char kUnsupportedCodecs[] = "vp8,foo";
-const char kSupportedCodecs[] = "vp8,vp8";
+const char kSupportedVideoCodecs[] = "vp8,vp8";
 
 const char kDefaultSecurityOrigin[] = "https://example.com/";
 
 // The IDL for MediaKeySystemConfiguration specifies some defaults, so
 // create a default object that mimics what would be created if an empty
 // dictionary was passed in.
 blink::WebMediaKeySystemConfiguration DefaultConfiguration() {
   // http://w3c.github.io/encrypted-media/#mediakeysystemconfiguration-dictionary
   // If this member (sessionTypes) is not present when the dictionary
   // is passed to requestMediaKeySystemAccess(), the dictionary will
   // be treated as if this member is set to [ "temporary" ].
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
 
   blink::WebMediaKeySystemConfiguration config;
   config.label = "";
   config.sessionTypes = session_types;
   return config;
 }
 
+// EME spec requires that at least one of |video_capabilities| and
+// |audio_capabilities| be specified. Add a single valid audio capability
+// to the DefaultConfiguration().
+blink::WebMediaKeySystemConfiguration UsableConfiguration() {
+  // blink code parses the contentType into mimeType and codecs, so mimic

[xhwang, 2017/02/02 23:12:49]

nit: Blink

[jrummell, 2017/02/03 22:30:24]

Done.

+  // that here.
+  std::vector<blink::WebMediaKeySystemMediaCapability> audio_capabilities(1);
+  audio_capabilities[0].mimeType = kSupportedAudioContainer;
+  audio_capabilities[0].codecs = kSupportedAudioCodec;
+
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  config.audioCapabilities = audio_capabilities;
+  return config;
+}
+
 class FakeKeySystems : public KeySystems {
  public:
   ~FakeKeySystems() override {
   }
 
   bool IsSupportedKeySystem(const std::string& key_system) const override {
     if (key_system == kSupported)
       return true;
     return false;
   }
@@ skipping 16 matching lines @@
   }
 
   // TODO(sandersd): Secure codec simulation.
   EmeConfigRule GetContentTypeConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& container_mime_type,
       const std::vector<std::string>& codecs) const override {
     if (container_mime_type == kUnsupportedContainer)
       return EmeConfigRule::NOT_SUPPORTED;
-    DCHECK_EQ(kSupportedContainer, container_mime_type);
+    switch (media_type) {
+      case EmeMediaType::AUDIO:
+        DCHECK_EQ(kSupportedAudioContainer, container_mime_type);
+        break;
+      case EmeMediaType::VIDEO:
+        DCHECK_EQ(kSupportedVideoContainer, container_mime_type);
+        break;
+    }
     for (const std::string& codec : codecs) {
       if (codec == kUnsupportedCodec)
         return EmeConfigRule::NOT_SUPPORTED;
-      DCHECK_EQ(kSupportedCodec, codec);
+      switch (media_type) {
+        case EmeMediaType::AUDIO:
+          DCHECK_EQ(kSupportedAudioCodec, codec);
+          break;
+        case EmeMediaType::VIDEO:
+          DCHECK_EQ(kSupportedVideoCodec, codec);
+          break;
+      }
     }
     return EmeConfigRule::SUPPORTED;
   }
 
   EmeConfigRule GetRobustnessConfigRule(
       const std::string& key_system,
       EmeMediaType media_type,
       const std::string& requested_robustness) const override {
     if (requested_robustness.empty())
       return EmeConfigRule::SUPPORTED;
@@ skipping 174 matching lines @@
             config.persistentState);
 
   // If this member is not present when the dictionary is passed to
   // requestMediaKeySystemAccess(), the dictionary will be treated as
   // if this member is set to [ "temporary" ].
   ASSERT_EQ(1u, config.sessionTypes.size());
   ASSERT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
             config.sessionTypes[0]);
 }
 
-// Most of the tests below assume that the default config is valid.
 TEST_F(KeySystemConfigSelectorTest, EmptyConfig) {
+  // EME spec requires that at least one of |video_capabilities| and
+  // |audio_capabilities| be specified, so the default config is invalid.
   configs_.push_back(DefaultConfiguration());

[xhwang, 2017/02/02 23:12:49]

Looking at this, maybe EmptyConfiguration() would make more sense. Then you
don't need the ", so the..." part.

[jrummell, 2017/02/03 22:30:24]

Done.

+  ASSERT_TRUE(SelectConfigReturnsError());
+}
+
+// Most of the tests below assume that the the usable config is valid.
+// Tests that touch |video_capabilities| and/or |audio_capabilities| can
+// modify the default config.
+
+TEST_F(KeySystemConfigSelectorTest, UsableConfig) {
+  configs_.push_back(UsableConfiguration());
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ("", config_.label);
   EXPECT_TRUE(config_.initDataTypes.isEmpty());
-  EXPECT_TRUE(config_.audioCapabilities.isEmpty());
+  EXPECT_EQ(1u, config_.audioCapabilities.size());
   EXPECT_TRUE(config_.videoCapabilities.isEmpty());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.distinctiveIdentifier);
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.persistentState);
   ASSERT_EQ(1u, config_.sessionTypes.size());
   EXPECT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
             config_.sessionTypes[0]);
 }
 
 TEST_F(KeySystemConfigSelectorTest, Label) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.label = "foo";
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ("foo", config_.label);
 }
 
 // --- keySystem ---
 // Empty is not tested because the empty check is in Blink.
 
 TEST_F(KeySystemConfigSelectorTest, KeySystem_NonAscii) {
   key_system_ = "\xde\xad\xbe\xef";
-  configs_.push_back(DefaultConfiguration());
+  configs_.push_back(UsableConfiguration());
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, KeySystem_Unsupported) {
   key_system_ = kUnsupported;
-  configs_.push_back(DefaultConfiguration());
+  configs_.push_back(UsableConfiguration());
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 // --- initDataTypes ---
 
 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_Empty) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
 }
 
 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_NoneSupported) {
   key_systems_->init_data_type_webm_supported_ = true;
 
   std::vector<blink::WebEncryptedMediaInitDataType> init_data_types;
   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Unknown);
   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Cenc);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.initDataTypes = init_data_types;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_SubsetSupported) {
   key_systems_->init_data_type_webm_supported_ = true;
 
   std::vector<blink::WebEncryptedMediaInitDataType> init_data_types;
   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Unknown);
   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Cenc);
   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Webm);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.initDataTypes = init_data_types;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.initDataTypes.size());
   EXPECT_EQ(blink::WebEncryptedMediaInitDataType::Webm,
             config_.initDataTypes[0]);
 }
 
 // --- distinctiveIdentifier ---
 
 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Default) {
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.distinctiveIdentifier);
 }
 
 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Forced) {
   media_permission_->is_granted = true;
   key_systems_->distinctive_identifier = EmeFeatureSupport::ALWAYS_ENABLED;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.distinctiveIdentifier);
 }
 
 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Blocked) {
   key_systems_->distinctive_identifier = EmeFeatureSupport::NOT_SUPPORTED;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_RequestsPermission) {
   media_permission_->is_granted = true;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.distinctiveIdentifier);
 }
 
 TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_RespectsPermission) {
   media_permission_->is_granted = false;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsError());
 }
 
 // --- persistentState ---
 
 TEST_F(KeySystemConfigSelectorTest, PersistentState_Default) {
   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed,
             config_.persistentState);
 }
 
 TEST_F(KeySystemConfigSelectorTest, PersistentState_Forced) {
   key_systems_->persistent_state = EmeFeatureSupport::ALWAYS_ENABLED;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.persistentState);
 }
 
 TEST_F(KeySystemConfigSelectorTest, PersistentState_Blocked) {
   key_systems_->persistent_state = EmeFeatureSupport::ALWAYS_ENABLED;
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 // --- sessionTypes ---
 
 TEST_F(KeySystemConfigSelectorTest, SessionTypes_Empty) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
 
   // Default configuration has [ "temporary" ].
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   config.sessionTypes = session_types;
 
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_TRUE(config_.sessionTypes.isEmpty());
 }
 
 TEST_F(KeySystemConfigSelectorTest, SessionTypes_SubsetSupported) {
   // Allow persistent state, as it would be required to be successful.
   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
   key_systems_->persistent_license = EmeSessionTypeSupport::NOT_SUPPORTED;
 
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
   session_types.push_back(
       blink::WebEncryptedMediaSessionType::PersistentLicense);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.sessionTypes = session_types;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, SessionTypes_AllSupported) {
   // Allow persistent state, and expect it to be required.
   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
   key_systems_->persistent_license = EmeSessionTypeSupport::SUPPORTED;
 
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   session_types.push_back(blink::WebEncryptedMediaSessionType::Temporary);
   session_types.push_back(
       blink::WebEncryptedMediaSessionType::PersistentLicense);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   config.sessionTypes = session_types;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.persistentState);
   ASSERT_EQ(2u, config_.sessionTypes.size());
   EXPECT_EQ(blink::WebEncryptedMediaSessionType::Temporary,
             config_.sessionTypes[0]);
   EXPECT_EQ(blink::WebEncryptedMediaSessionType::PersistentLicense,
             config_.sessionTypes[1]);
 }
 
 TEST_F(KeySystemConfigSelectorTest, SessionTypes_PermissionCanBeRequired) {
   media_permission_->is_granted = true;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
   key_systems_->persistent_state = EmeFeatureSupport::REQUESTABLE;
   key_systems_->persistent_license =
       EmeSessionTypeSupport::SUPPORTED_WITH_IDENTIFIER;
 
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
   session_types.push_back(
       blink::WebEncryptedMediaSessionType::PersistentLicense);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   config.sessionTypes = session_types;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   EXPECT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Required,
             config_.distinctiveIdentifier);
 }
 
 // --- videoCapabilities ---
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Empty) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_NoneSupported) {
   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 = kSupportedContainer;
+  video_capabilities[1].mimeType = kSupportedVideoContainer;
   video_capabilities[1].codecs = kUnsupportedCodec;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   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 = kSupportedContainer;
+  video_capabilities[1].mimeType = kSupportedVideoContainer;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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(kSupportedContainer, config_.videoCapabilities[0].mimeType);
+  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 = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[1].contentType = "b";
-  video_capabilities[1].mimeType = kSupportedContainer;
-  video_capabilities[1].codecs = kSupportedCodecs;
+  video_capabilities[1].mimeType = kSupportedVideoContainer;
+  video_capabilities[1].codecs = kSupportedVideoCodecs;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(2u, config_.videoCapabilities.size());
   EXPECT_EQ("a", config_.videoCapabilities[0].contentType);
   EXPECT_EQ("b", config_.videoCapabilities[1].contentType);
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        VideoCapabilities_Codecs_SubsetSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].codecs = kUnsupportedCodecs;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Codecs_AllSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(1);
   video_capabilities[0].contentType = "a";
-  video_capabilities[0].mimeType = kSupportedContainer;
-  video_capabilities[0].codecs = kSupportedCodecs;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
+  video_capabilities[0].codecs = kSupportedVideoCodecs;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.videoCapabilities = video_capabilities;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ(1u, config_.videoCapabilities.size());
-  EXPECT_EQ(kSupportedCodecs, config_.videoCapabilities[0].codecs);
+  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 = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   ASSERT_TRUE(video_capabilities[0].robustness.isEmpty());
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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 = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kSupported;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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 = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kUnsupported;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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 = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kRequireIdentifier;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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 = kSupportedContainer;
+  video_capabilities[0].mimeType = kSupportedVideoContainer;
   video_capabilities[0].robustness = kRecommendIdentifier;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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 = kSupportedContainer;
+  audio_capabilities[1].mimeType = kSupportedAudioContainer;
 
   blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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(kSupportedContainer, config_.audioCapabilities[0].mimeType);
+  EXPECT_EQ(kSupportedAudioContainer, config_.audioCapabilities[0].mimeType);
 }
 
 // --- Multiple configurations ---
 
 TEST_F(KeySystemConfigSelectorTest, Configurations_AllSupported) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.label = "a";
   configs_.push_back(config);
   config.label = "b";
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ("a", config_.label);
 }
 
 TEST_F(KeySystemConfigSelectorTest, Configurations_SubsetSupported) {
-  blink::WebMediaKeySystemConfiguration config1 = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config1 = UsableConfiguration();
   config1.label = "a";
   std::vector<blink::WebEncryptedMediaInitDataType> init_data_types;
   init_data_types.push_back(blink::WebEncryptedMediaInitDataType::Unknown);
   config1.initDataTypes = init_data_types;
   configs_.push_back(config1);
 
-  blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config2 = UsableConfiguration();
   config2.label = "b";
   configs_.push_back(config2);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
   ASSERT_EQ("b", config_.label);
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        Configurations_FirstRequiresPermission_Allowed) {
   media_permission_->is_granted = true;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
-  blink::WebMediaKeySystemConfiguration config1 = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config1 = UsableConfiguration();
   config1.label = "a";
   config1.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config1);
 
-  blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config2 = UsableConfiguration();
   config2.label = "b";
   configs_.push_back(config2);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   ASSERT_EQ("a", config_.label);
 }
 
 TEST_F(KeySystemConfigSelectorTest,
        Configurations_FirstRequiresPermission_Rejected) {
   media_permission_->is_granted = false;
   key_systems_->distinctive_identifier = EmeFeatureSupport::REQUESTABLE;
 
-  blink::WebMediaKeySystemConfiguration config1 = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config1 = UsableConfiguration();
   config1.label = "a";
   config1.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config1);
 
-  blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config2 = UsableConfiguration();
   config2.label = "b";
   configs_.push_back(config2);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   ASSERT_EQ("b", config_.label);
 }
 
 }  // namespace media