EME: Fail requestMediaKeySystemAccess if no capabilities specified

media/blink/key_system_config_selector_unittest.cc

Index: media/blink/key_system_config_selector_unittest.cc
diff --git a/media/blink/key_system_config_selector_unittest.cc b/media/blink/key_system_config_selector_unittest.cc
index 0ca129571a52937dbfc77eb2da42198cc2b5ff24..5804241c0160957d62a298555408850b01e46ea0 100644
--- a/media/blink/key_system_config_selector_unittest.cc
+++ b/media/blink/key_system_config_selector_unittest.cc
@@ -29,16 +29,16 @@ 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/";
 
@@ -59,6 +59,21 @@ blink::WebMediaKeySystemConfiguration DefaultConfiguration() {
   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 {
@@ -95,11 +110,25 @@ class FakeKeySystems : public KeySystems {
       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;
   }
@@ -294,14 +323,24 @@ TEST_F(KeySystemConfigSelectorTest, DefaultConfig) {
             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);
@@ -313,7 +352,7 @@ TEST_F(KeySystemConfigSelectorTest, EmptyConfig) {
 }
 
 TEST_F(KeySystemConfigSelectorTest, Label) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.label = "foo";
   configs_.push_back(config);
 
@@ -326,20 +365,20 @@ TEST_F(KeySystemConfigSelectorTest, Label) {
 
 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());
@@ -352,7 +391,7 @@ TEST_F(KeySystemConfigSelectorTest, InitDataTypes_NoneSupported) {
   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);
 
@@ -367,7 +406,7 @@ TEST_F(KeySystemConfigSelectorTest, InitDataTypes_SubsetSupported) {
   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);
 
@@ -382,7 +421,7 @@ TEST_F(KeySystemConfigSelectorTest, InitDataTypes_SubsetSupported) {
 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);
@@ -396,7 +435,7 @@ 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);
@@ -409,7 +448,7 @@ TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_Forced) {
 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);
@@ -421,7 +460,7 @@ 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);
@@ -435,7 +474,7 @@ 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);
@@ -448,7 +487,7 @@ TEST_F(KeySystemConfigSelectorTest, DistinctiveIdentifier_RespectsPermission) {
 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);
@@ -461,7 +500,7 @@ TEST_F(KeySystemConfigSelectorTest, PersistentState_Default) {
 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);
@@ -474,7 +513,7 @@ TEST_F(KeySystemConfigSelectorTest, PersistentState_Forced) {
 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);
@@ -485,7 +524,7 @@ TEST_F(KeySystemConfigSelectorTest, PersistentState_Blocked) {
 // --- sessionTypes ---
 
 TEST_F(KeySystemConfigSelectorTest, SessionTypes_Empty) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
 
   // Default configuration has [ "temporary" ].
   std::vector<blink::WebEncryptedMediaSessionType> session_types;
@@ -507,7 +546,7 @@ TEST_F(KeySystemConfigSelectorTest, SessionTypes_SubsetSupported) {
   session_types.push_back(
       blink::WebEncryptedMediaSessionType::PersistentLicense);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.sessionTypes = session_types;
   configs_.push_back(config);
 
@@ -524,7 +563,7 @@ TEST_F(KeySystemConfigSelectorTest, SessionTypes_AllSupported) {
   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;
@@ -551,7 +590,7 @@ TEST_F(KeySystemConfigSelectorTest, SessionTypes_PermissionCanBeRequired) {
   session_types.push_back(
       blink::WebEncryptedMediaSessionType::PersistentLicense);
 
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   config.persistentState =
@@ -567,7 +606,7 @@ TEST_F(KeySystemConfigSelectorTest, SessionTypes_PermissionCanBeRequired) {
 // --- videoCapabilities ---
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Empty) {
-  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+  blink::WebMediaKeySystemConfiguration config = UsableConfiguration();
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
@@ -578,7 +617,7 @@ TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_NoneSupported) {
   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();
@@ -593,7 +632,7 @@ TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) {
   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;
@@ -602,16 +641,16 @@ TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_SubsetSupported) {
   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;
@@ -627,7 +666,7 @@ 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();
@@ -640,8 +679,8 @@ TEST_F(KeySystemConfigSelectorTest,
 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;
@@ -649,13 +688,13 @@ TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Codecs_AllSupported) {
 
   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();
@@ -670,7 +709,7 @@ TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Empty) {
 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();
@@ -685,7 +724,7 @@ TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_Robustness_Supported) {
 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();
@@ -702,7 +741,7 @@ TEST_F(KeySystemConfigSelectorTest,
 
   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();
@@ -721,7 +760,7 @@ TEST_F(KeySystemConfigSelectorTest,
 
   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();
@@ -742,7 +781,7 @@ TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) {
   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;
@@ -751,13 +790,13 @@ TEST_F(KeySystemConfigSelectorTest, AudioCapabilities_SubsetSupported) {
   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";
@@ -768,14 +807,14 @@ TEST_F(KeySystemConfigSelectorTest, Configurations_AllSupported) {
 }
 
 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);
 
@@ -788,13 +827,13 @@ TEST_F(KeySystemConfigSelectorTest,
   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);
 
@@ -807,13 +846,13 @@ TEST_F(KeySystemConfigSelectorTest,
   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);