Don't update Media.EME.KeySystemSupport UMA for unprefixed EME

media/base/key_systems_unittest.cc

Index: media/base/key_systems_unittest.cc
diff --git a/media/base/key_systems_unittest.cc b/media/base/key_systems_unittest.cc
index afd9dc06e25bdcb4ceb2ddb50446632316550542..5fdd220774a2000576c4627b3924202d62cb8ea5 100644
--- a/media/base/key_systems_unittest.cc
+++ b/media/base/key_systems_unittest.cc
@@ -294,7 +294,7 @@ class KeySystemsTest : public testing::Test {
 TEST_F(KeySystemsTest, EmptyKeySystem) {
   EXPECT_FALSE(IsConcreteSupportedKeySystem(std::string()));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), std::string()));
+      kVideoWebM, no_codecs(), std::string(), false));
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(std::string()));
 }
 
@@ -302,14 +302,14 @@ TEST_F(KeySystemsTest, EmptyKeySystem) {
 TEST_F(KeySystemsTest, ClearKey) {
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kClearKey));
+      kVideoWebM, no_codecs(), kClearKey, false));
 
   EXPECT_EQ("ClearKey", GetKeySystemNameForUMA(kClearKey));
 
   // Prefixed Clear Key is not supported internally.
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kPrefixedClearKey));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kPrefixedClearKey));
+      kVideoWebM, no_codecs(), kPrefixedClearKey, false));
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kPrefixedClearKey));
 }
 
@@ -319,7 +319,7 @@ TEST_F(KeySystemsTest, Basic_UnrecognizedKeySystem) {
 
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kUnrecognized));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUnrecognized));
+      kVideoWebM, no_codecs(), kUnrecognized, false));
 
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kUnrecognized));
 
@@ -340,7 +340,7 @@ TEST_F(KeySystemsTest, Basic_UnrecognizedKeySystem) {
 TEST_F(KeySystemsTest, Basic_UsesAesDecryptor) {
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAes));
+      kVideoWebM, no_codecs(), kUsesAes, false));
 
   // No UMA value for this test key system.
   EXPECT_EQ("UseAes", GetKeySystemNameForUMA(kUsesAes));
@@ -358,54 +358,54 @@ TEST_F(KeySystemsTest,
        IsSupportedKeySystemWithMediaMimeType_UsesAesDecryptor_TypesContainer1) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_codec(), kUsesAes));
+      kVideoWebM, vp8_codec(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp80_codec(), kUsesAes));
+      kVideoWebM, vp80_codec(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kUsesAes));
+      kVideoWebM, vp8_and_vorbis_codecs(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_codec(), kUsesAes));
+      kVideoWebM, vp9_codec(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp90_codec(), kUsesAes));
+      kVideoWebM, vp90_codec(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_and_vorbis_codecs(), kUsesAes));
+      kVideoWebM, vp9_and_vorbis_codecs(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vorbis_codec(), kUsesAes));
+      kVideoWebM, vorbis_codec(), kUsesAes, false));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, foovideo_codec(), kUsesAes));
+      kVideoWebM, foovideo_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, unknown_codec(), kUsesAes));
+      kVideoWebM, unknown_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, mixed_codecs(), kUsesAes));
+      kVideoWebM, mixed_codecs(), kUsesAes, false));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, no_codecs(), kUsesAes));
+      kAudioWebM, no_codecs(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vorbis_codec(), kUsesAes));
+      kAudioWebM, vorbis_codec(), kUsesAes, false));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp8_codec(), kUsesAes));
+      kAudioWebM, vp8_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp8_and_vorbis_codecs(), kUsesAes));
+      kAudioWebM, vp8_and_vorbis_codecs(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp9_codec(), kUsesAes));
+      kAudioWebM, vp9_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp9_and_vorbis_codecs(), kUsesAes));
+      kAudioWebM, vp9_and_vorbis_codecs(), kUsesAes, false));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, fooaudio_codec(), kUsesAes));
+      kAudioWebM, fooaudio_codec(), kUsesAes, false));
 }
 
 // No parent is registered for UsesAes.
 TEST_F(KeySystemsTest, Parent_NoParentRegistered) {
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kUsesAesParent));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAesParent));
+      kVideoWebM, no_codecs(), kUsesAesParent, false));
 
   // The parent is not supported for most things.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kUsesAesParent));
@@ -425,47 +425,47 @@ TEST_F(KeySystemsTest, IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.ClEaR"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org.example.ClEaR"));
+      kVideoWebM, no_codecs(), "org.example.ClEaR", false));
 
   // TLDs are not allowed.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org."));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org."));
+      kVideoWebM, no_codecs(), "org.", false));
   EXPECT_FALSE(IsConcreteSupportedKeySystem("com"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "com"));
+      kVideoWebM, no_codecs(), "com", false));
 
   // Extra period.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example."));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org.example."));
+      kVideoWebM, no_codecs(), "org.example.", false));
 
   // Incomplete.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.clea"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org.example.clea"));
+      kVideoWebM, no_codecs(), "org.example.clea", false));
 
   // Extra character.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.clearz"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org.example.clearz"));
+      kVideoWebM, no_codecs(), "org.example.clearz", false));
 
   // There are no child key systems for UsesAes.
   EXPECT_FALSE(IsConcreteSupportedKeySystem("org.example.clear.foo"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org.example.clear.foo"));
+      kVideoWebM, no_codecs(), "org.example.clear.foo", false));
 }
 
 TEST_F(KeySystemsTest, IsSupportedKeySystemWithMediaMimeType_NoType) {
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      std::string(), no_codecs(), kUsesAes));
+      std::string(), no_codecs(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      std::string(), no_codecs(), kUsesAesParent));
+      std::string(), no_codecs(), kUsesAesParent, false));
 
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      std::string(), no_codecs(), "org.example.foo"));
+      std::string(), no_codecs(), "org.example.foo", false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      std::string(), no_codecs(), "org.example.clear.foo"));
+      std::string(), no_codecs(), "org.example.clear.foo", false));
 }
 
 // Tests the second registered container type.
@@ -474,49 +474,49 @@ TEST_F(KeySystemsTest,
        IsSupportedKeySystemWithMediaMimeType_UsesAesDecryptor_TypesContainer2) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kUsesAes));
+      kVideoFoo, no_codecs(), kUsesAes, false));
   // The parent should be supported but is not. See http://crbug.com/164303.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kUsesAesParent));
+      kVideoFoo, no_codecs(), kUsesAesParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_codec(), kUsesAes));
+      kVideoFoo, foovideo_codec(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_and_fooaudio_codecs(), kUsesAes));
+      kVideoFoo, foovideo_and_fooaudio_codecs(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, fooaudio_codec(), kUsesAes));
+      kVideoFoo, fooaudio_codec(), kUsesAes, false));
 
   // Extended codecs fail because this is handled by SimpleWebMimeRegistryImpl.
   // They should really pass canPlayType().
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_extended_codec(), kUsesAes));
+      kVideoFoo, foovideo_extended_codec(), kUsesAes, false));
 
   // Invalid codec format.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_dot_codec(), kUsesAes));
+      kVideoFoo, foovideo_dot_codec(), kUsesAes, false));
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, vp8_codec(), kUsesAes));
+      kVideoFoo, vp8_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, unknown_codec(), kUsesAes));
+      kVideoFoo, unknown_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, mixed_codecs(), kUsesAes));
+      kVideoFoo, mixed_codecs(), kUsesAes, false));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, no_codecs(), kUsesAes));
+      kAudioFoo, no_codecs(), kUsesAes, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, fooaudio_codec(), kUsesAes));
+      kAudioFoo, fooaudio_codec(), kUsesAes, false));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, foovideo_codec(), kUsesAes));
+      kAudioFoo, foovideo_codec(), kUsesAes, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, foovideo_and_fooaudio_codecs(), kUsesAes));
+      kAudioFoo, foovideo_and_fooaudio_codecs(), kUsesAes, false));
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, vorbis_codec(), kUsesAes));
+      kAudioFoo, vorbis_codec(), kUsesAes, false));
 }
 
 //
@@ -526,7 +526,7 @@ TEST_F(KeySystemsTest,
 TEST_F(KeySystemsTest, Basic_ExternalDecryptor) {
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
+      kVideoWebM, no_codecs(), kExternal, false));
 
   EXPECT_FALSE(CanUseAesDecryptor(kExternal));
 #if defined(ENABLE_PEPPER_CDMS)
@@ -538,7 +538,7 @@ TEST_F(KeySystemsTest, Parent_ParentRegistered) {
   // The parent system is not a concrete system but is supported.
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kExternalParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternalParent));
+      kVideoWebM, no_codecs(), kExternalParent, false));
 
   // The parent is not supported for most things.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kExternalParent));
@@ -559,73 +559,73 @@ TEST_F(
     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer1) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
+      kVideoWebM, no_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_codec(), kExternal));
+      kVideoWebM, vp8_codec(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp80_codec(), kExternal));
+      kVideoWebM, vp80_codec(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kExternal));
+      kVideoWebM, vp8_and_vorbis_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_codec(), kExternal));
+      kVideoWebM, vp9_codec(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp90_codec(), kExternal));
+      kVideoWebM, vp90_codec(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_and_vorbis_codecs(), kExternal));
+      kVideoWebM, vp9_and_vorbis_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vorbis_codec(), kExternal));
+      kVideoWebM, vorbis_codec(), kExternal, false));
 
   // Valid video types - parent key system.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternalParent));
+      kVideoWebM, no_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_codec(), kExternalParent));
+      kVideoWebM, vp8_codec(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp80_codec(), kExternalParent));
+      kVideoWebM, vp80_codec(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kExternalParent));
+      kVideoWebM, vp8_and_vorbis_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_codec(), kExternalParent));
+      kVideoWebM, vp9_codec(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp90_codec(), kExternalParent));
+      kVideoWebM, vp90_codec(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_and_vorbis_codecs(), kExternalParent));
+      kVideoWebM, vp9_and_vorbis_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vorbis_codec(), kExternalParent));
+      kVideoWebM, vorbis_codec(), kExternalParent, false));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, foovideo_codec(), kExternal));
+      kVideoWebM, foovideo_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, unknown_codec(), kExternal));
+      kVideoWebM, unknown_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, mixed_codecs(), kExternal));
+      kVideoWebM, mixed_codecs(), kExternal, false));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, no_codecs(), kExternal));
+      kAudioWebM, no_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vorbis_codec(), kExternal));
+      kAudioWebM, vorbis_codec(), kExternal, false));
 
   // Valid audio types - parent key system.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, no_codecs(), kExternalParent));
+      kAudioWebM, no_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vorbis_codec(), kExternalParent));
+      kAudioWebM, vorbis_codec(), kExternalParent, false));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp8_codec(), kExternal));
+      kAudioWebM, vp8_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp8_and_vorbis_codecs(), kExternal));
+      kAudioWebM, vp8_and_vorbis_codecs(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp9_codec(), kExternal));
+      kAudioWebM, vp9_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vp9_and_vorbis_codecs(), kExternal));
+      kAudioWebM, vp9_and_vorbis_codecs(), kExternal, false));
 
   // Non-Webm codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, fooaudio_codec(), kExternal));
+      kAudioWebM, fooaudio_codec(), kExternal, false));
 }
 
 TEST_F(
@@ -633,62 +633,62 @@ TEST_F(
     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer2) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kExternal));
+      kVideoFoo, no_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_codec(), kExternal));
+      kVideoFoo, foovideo_codec(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_and_fooaudio_codecs(), kExternal));
+      kVideoFoo, foovideo_and_fooaudio_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, fooaudio_codec(), kExternal));
+      kVideoFoo, fooaudio_codec(), kExternal, false));
 
   // Valid video types - parent key system.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kExternalParent));
+      kVideoFoo, no_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_codec(), kExternalParent));
+      kVideoFoo, foovideo_codec(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_and_fooaudio_codecs(), kExternalParent));
+      kVideoFoo, foovideo_and_fooaudio_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, fooaudio_codec(), kExternalParent));
+      kVideoFoo, fooaudio_codec(), kExternalParent, false));
 
   // Extended codecs fail because this is handled by SimpleWebMimeRegistryImpl.
   // They should really pass canPlayType().
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_extended_codec(), kExternal));
+      kVideoFoo, foovideo_extended_codec(), kExternal, false));
 
   // Invalid codec format.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_dot_codec(), kExternal));
+      kVideoFoo, foovideo_dot_codec(), kExternal, false));
 
   // Non-container2 codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, vp8_codec(), kExternal));
+      kVideoFoo, vp8_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, unknown_codec(), kExternal));
+      kVideoFoo, unknown_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, mixed_codecs(), kExternal));
+      kVideoFoo, mixed_codecs(), kExternal, false));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, no_codecs(), kExternal));
+      kAudioFoo, no_codecs(), kExternal, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, fooaudio_codec(), kExternal));
+      kAudioFoo, fooaudio_codec(), kExternal, false));
 
   // Valid audio types - parent key system.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, no_codecs(), kExternalParent));
+      kAudioFoo, no_codecs(), kExternalParent, false));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, fooaudio_codec(), kExternalParent));
+      kAudioFoo, fooaudio_codec(), kExternalParent, false));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, foovideo_codec(), kExternal));
+      kAudioFoo, foovideo_codec(), kExternal, false));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, foovideo_and_fooaudio_codecs(), kExternal));
+      kAudioFoo, foovideo_and_fooaudio_codecs(), kExternal, false));
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, vorbis_codec(), kExternal));
+      kAudioFoo, vorbis_codec(), kExternal, false));
 }
 
 TEST_F(KeySystemsTest, KeySystemNameForUMA) {
@@ -703,19 +703,37 @@ TEST_F(KeySystemsTest, KeySystemNameForUMA) {
 TEST_F(KeySystemsTest, KeySystemsUpdate) {
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAes));
+      kVideoWebM, no_codecs(), kUsesAes, false));
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
+      kVideoWebM, no_codecs(), kExternal, false));
 
   UpdateClientKeySystems();
 
   EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAes));
+      kVideoWebM, no_codecs(), kUsesAes, false));
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
+      kVideoWebM, no_codecs(), kExternal, false));
+}
+
+TEST_F(KeySystemsTest, KeySystemsUpdateWithUMA) {
+  EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, no_codecs(), kUsesAes, true));
+  EXPECT_TRUE(IsConcreteSupportedKeySystem(kExternal));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, no_codecs(), kExternal, true));
+
+  UpdateClientKeySystems();
+
+  EXPECT_TRUE(IsConcreteSupportedKeySystem(kUsesAes));
+  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, no_codecs(), kUsesAes, true));
+  EXPECT_FALSE(IsConcreteSupportedKeySystem(kExternal));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, no_codecs(), kExternal, true));
 }
 
 }  // namespace media