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

media/base/key_systems_unittest.cc

 // Copyright 2013 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/logging.h"
 #include "media/base/eme_constants.h"
 #include "media/base/key_system_info.h"
@@ skipping 276 matching lines @@
   CodecVector mixed_codecs_;
 
   TestMediaClient test_media_client_;
 };
 
 // TODO(ddorwin): Consider moving GetPepperType() calls out to their own 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()));
 }
 
 // Clear Key is the only key system registered in content.
 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));
 }
 
 // The key system is not registered and therefore is unrecognized.
 TEST_F(KeySystemsTest, Basic_UnrecognizedKeySystem) {
   static const char* const kUnrecognized = "org.example.unrecognized";
 
   EXPECT_FALSE(IsConcreteSupportedKeySystem(kUnrecognized));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUnrecognized));
+      kVideoWebM, no_codecs(), kUnrecognized, false));
 
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kUnrecognized));
 
   bool can_use = false;
   EXPECT_DEBUG_DEATH_PORTABLE(
       can_use = CanUseAesDecryptor(kUnrecognized),
       "org.example.unrecognized is not a known concrete system");
   EXPECT_FALSE(can_use);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kUnrecognized),
                      "org.example.unrecognized is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 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));
 
   EXPECT_TRUE(CanUseAesDecryptor(kUsesAes));
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kUsesAes),
                      "org.example.clear is not Pepper-based");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 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));
   bool result = false;
   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kUsesAesParent),
                               "org.example is not a known concrete system");
   EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kUsesAesParent),
                      "org.example is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 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.
 // TODO(ddorwin): Combined with TypesContainer1 in a future CL.
 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));
 }
 
 //
 // Non-AesDecryptor-based key system.
 //
 
 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)
   EXPECT_EQ("application/x-ppapi-external-cdm", GetPepperType(kExternal));
 #endif  // defined(ENABLE_PEPPER_CDMS)
 }
 
 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));
   bool result = false;
   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kExternalParent),
                               "com.example is not a known concrete system");
   EXPECT_FALSE(result);
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kExternalParent),
                      "com.example is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(
     KeySystemsTest,
     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(
     KeySystemsTest,
     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) {
   EXPECT_EQ("ClearKey", GetKeySystemNameForUMA(kClearKey));
   // Prefixed is not supported internally.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kPrefixedClearKey));
 
   // External Clear Key never has a UMA name.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kExternalClearKey));
 }
 
 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