EME: Update MediaKeySystemConfiguration defaults; require non-empty capabilities

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 24 matching lines @@
 const char kUnsupportedContainer[] = "video/foo";
 
 // TODO(sandersd): Extended codec variants (requires proprietary codec support).
 const char kSupportedCodec[] = "vp8";
 const char kUnsupportedCodec[] = "foo";
 const char kUnsupportedCodecs[] = "vp8,foo";
 const char kSupportedCodecs[] = "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;
+}
+
 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 182 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(KeySystemConfigSelectorTest);
 };
 
 // --- Basics ---
 
 TEST_F(KeySystemConfigSelectorTest, NoConfigs) {
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
-// Most of the tests below assume that an empty config is valid.
+TEST_F(KeySystemConfigSelectorTest, DefaultConfig) {
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+
+  // label = "";
+  ASSERT_EQ("", config.label);
+
+  // initDataTypes = [];
+  ASSERT_EQ(0u, config.initDataTypes.size());
+
+  // audioCapabilities = [];
+  ASSERT_EQ(0u, config.audioCapabilities.size());
+
+  // videoCapabilities = [];
+  ASSERT_EQ(0u, config.videoCapabilities.size());
+
+  // distinctiveIdentifier = "optional";
+  ASSERT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Optional,
+            config.distinctiveIdentifier);
+
+  // persistentState = "optional";
+  ASSERT_EQ(blink::WebMediaKeySystemConfiguration::Requirement::Optional,
+            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) {
-  configs_.push_back(blink::WebMediaKeySystemConfiguration());
+  configs_.push_back(DefaultConfiguration());
 
   ASSERT_TRUE(SelectConfigReturnsConfig());
-  EXPECT_TRUE(config_.label.isNull());
+  EXPECT_EQ("", config_.label);
   EXPECT_TRUE(config_.initDataTypes.isEmpty());
   EXPECT_TRUE(config_.audioCapabilities.isEmpty());
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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(blink::WebMediaKeySystemConfiguration());
+  configs_.push_back(DefaultConfiguration());
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 TEST_F(KeySystemConfigSelectorTest, KeySystem_Unsupported) {
   key_system_ = kUnsupported;
-  configs_.push_back(blink::WebMediaKeySystemConfiguration());
+  configs_.push_back(DefaultConfiguration());
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 // --- initDataTypes ---
 
 TEST_F(KeySystemConfigSelectorTest, InitDataTypes_Empty) {
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasInitDataTypes = true;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   configs_.push_back(config);
 
-  ASSERT_TRUE(SelectConfigReturnsError());
+  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;
-  config.hasInitDataTypes = true;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
-  config.hasInitDataTypes = true;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::NotAllowed;
   configs_.push_back(config);
 
   ASSERT_TRUE(SelectConfigReturnsError());
 }
 
 // --- sessionTypes ---
 
 TEST_F(KeySystemConfigSelectorTest, SessionTypes_Empty) {
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasSessionTypes = true;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
+
+  // 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;
-  config.hasSessionTypes = true;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
-  config.hasSessionTypes = true;
   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;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   config.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
   config.persistentState =
       blink::WebMediaKeySystemConfiguration::Requirement::Optional;
-  config.hasSessionTypes = true;
   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;
-  config.hasVideoCapabilities = true;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   configs_.push_back(config);
 
-  ASSERT_TRUE(SelectConfigReturnsError());
+  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].codecs = kUnsupportedCodec;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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);
 }
 
 TEST_F(KeySystemConfigSelectorTest, VideoCapabilities_AllSupported) {
   std::vector<blink::WebMediaKeySystemMediaCapability> video_capabilities(2);
   video_capabilities[0].contentType = "a";
   video_capabilities[0].mimeType = kSupportedContainer;
   video_capabilities[1].contentType = "b";
   video_capabilities[1].mimeType = kSupportedContainer;
   video_capabilities[1].codecs = kSupportedCodecs;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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].codecs = kUnsupportedCodecs;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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);
 }
 
 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].robustness = kSupported;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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].robustness = kUnsupported;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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].robustness = kRequireIdentifier;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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].robustness = kRecommendIdentifier;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasVideoCapabilities = true;
+  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;
 
-  blink::WebMediaKeySystemConfiguration config;
-  config.hasAudioCapabilities = true;
+  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);
 }
 
 // --- Multiple configurations ---
 
 TEST_F(KeySystemConfigSelectorTest, Configurations_AllSupported) {
-  blink::WebMediaKeySystemConfiguration config;
+  blink::WebMediaKeySystemConfiguration config = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config1 = DefaultConfiguration();
   config1.label = "a";
-  config1.hasInitDataTypes = true;
+  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;
+  blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config1 = DefaultConfiguration();
   config1.label = "a";
   config1.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config1);
 
-  blink::WebMediaKeySystemConfiguration config2;
+  blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
   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;
+  blink::WebMediaKeySystemConfiguration config1 = DefaultConfiguration();
   config1.label = "a";
   config1.distinctiveIdentifier =
       blink::WebMediaKeySystemConfiguration::Requirement::Required;
   configs_.push_back(config1);
 
-  blink::WebMediaKeySystemConfiguration config2;
+  blink::WebMediaKeySystemConfiguration config2 = DefaultConfiguration();
   config2.label = "b";
   configs_.push_back(config2);
 
   ASSERT_TRUE(SelectConfigRequestsPermissionAndReturnsConfig());
   ASSERT_EQ("b", config_.label);
 }
 
 }  // namespace media