Remove prefixed 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.
 
 // TODO(sandersd): Refactor to remove recomputed codec arrays, and generally
 // shorten and improve coverage.
 //   - http://crbug.com/417444
 //   - http://crbug.com/457438
 // TODO(sandersd): Add tests to cover codec vectors with empty items.
 // http://crbug.com/417461
@@ skipping 14 matching lines @@
 // kUsesAes uses the AesDecryptor like Clear Key.
 // kExternal uses an external CDM, such as Pepper-based or Android platform CDM.
 const char kUsesAes[] = "x-org.example.clear";
 const char kUsesAesParent[] = "x-org.example";  // Not registered.
 const char kUseAesNameForUMA[] = "UseAes";
 const char kExternal[] = "x-com.example.test";
 const char kExternalParent[] = "x-com.example";
 const char kExternalNameForUMA[] = "External";
 
 const char kClearKey[] = "org.w3.clearkey";
-const char kPrefixedClearKey[] = "webkit-org.w3.clearkey";
 const char kExternalClearKey[] = "org.chromium.externalclearkey";
 
 const char kAudioWebM[] = "audio/webm";
 const char kVideoWebM[] = "video/webm";
 const char kAudioFoo[] = "audio/foo";
 const char kVideoFoo[] = "video/foo";
 
 // Pick some arbitrary bit fields as long as they are not in conflict with the
 // real ones.
 enum TestCodec {
@@ skipping 90 matching lines @@
 TestMediaClient::TestMediaClient()
     : is_update_needed_(true), supports_external_key_system_(true) {
 }
 
 TestMediaClient::~TestMediaClient() {
 }
 
 void TestMediaClient::AddKeySystemsInfoForUMA(
     std::vector<KeySystemInfoForUMA>* key_systems_info_for_uma) {
   key_systems_info_for_uma->push_back(
-      media::KeySystemInfoForUMA(kUsesAes, kUseAesNameForUMA, false));
+      media::KeySystemInfoForUMA(kUsesAes, kUseAesNameForUMA));
   key_systems_info_for_uma->push_back(
-      media::KeySystemInfoForUMA(kExternal, kExternalNameForUMA, true));
+      media::KeySystemInfoForUMA(kExternal, kExternalNameForUMA));
 }
 
 bool TestMediaClient::IsKeySystemsUpdateNeeded() {
   return is_update_needed_;
 }
 
 void TestMediaClient::AddSupportedKeySystems(
     std::vector<KeySystemInfo>* key_systems) {
   DCHECK(is_update_needed_);
 
@@ skipping 201 matching lines @@
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(std::string()));
 }
 
 // Clear Key is the only key system registered in content.
 TEST_F(KeySystemsTest, ClearKey) {
   EXPECT_TRUE(IsSupportedKeySystem(kClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kClearKey));
 
   EXPECT_EQ("ClearKey", GetKeySystemNameForUMA(kClearKey));
-
-  // Prefixed Clear Key is not supported internally.
-  EXPECT_FALSE(IsSupportedKeySystem(kPrefixedClearKey));
-  EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kPrefixedClearKey));
 }
 
 TEST_F(KeySystemsTest, ClearKeyWithInitDataType) {
   EXPECT_TRUE(IsSupportedKeySystem(kClearKey));
   EXPECT_TRUE(
       IsSupportedKeySystemWithInitDataType(kClearKey, EmeInitDataType::WEBM));
   EXPECT_TRUE(
       IsSupportedKeySystemWithInitDataType(kClearKey, EmeInitDataType::KEYIDS));
 
   // All other InitDataTypes are not supported.
@@ skipping 194 matching lines @@
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternal));
 
   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) {
   // Unprefixed has no parent key system support.

[xhwang, 2016/02/19 23:39:14]

Now we only have one EME, we probably should stop using "unprefixed" in our code
base..

[ddorwin, 2016/02/20 01:04:46]

We can fix that as we find it. For this one, the concept of parent key system
will be removed, meaning we can delete this test. For now, it provides a
meaningful differentiation.

   EXPECT_FALSE(IsSupportedKeySystem(kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternalParent));
 
   // The parent is not supported for most things.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kExternalParent));
   EXPECT_FALSE(CanUseAesDecryptor(kExternalParent));
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string type;
   EXPECT_DEBUG_DEATH(type = GetPepperType(kExternalParent),
                      "x-com.example is not a known concrete system");
   EXPECT_TRUE(type.empty());
@@ skipping 16 matching lines @@
       kVideoWebM, vp90_codec(), kExternal));
 
   // Audio in a video container.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_and_vorbis_codecs(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp9_and_vorbis_codecs(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vorbis_codec(), kExternal));
 
-  // Valid video types - parent key system.
-  // Prefixed has parent key system support.
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_codec(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp80_codec(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_codec(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp90_codec(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_and_vorbis_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vorbis_codec(), kExternalParent));
-
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, foovideo_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, unknown_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, mixed_codecs(), kExternal));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vorbis_codec(), kExternal));
 
-  // Valid audio types - parent key system.
-  // Prefixed has parent key system support.
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, no_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vorbis_codec(), kExternalParent));
-
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp8_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp8_and_vorbis_codecs(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp9_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp9_and_vorbis_codecs(), kExternal));
 
@@ skipping 10 matching lines @@
       kVideoFoo, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_codec(), kExternal));
 
   // Audio in a video container.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_and_fooaudio_codecs(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, fooaudio_codec(), kExternal));
 
-  // Valid video types - parent key system.
-  // Prefixed has parent key system support.
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_codec(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_and_fooaudio_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, fooaudio_codec(), kExternalParent));
-
   // Extended codecs fail because this is handled by SimpleWebMimeRegistryImpl.
   // They should really pass canPlayType().
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_extended_codec(), kExternal));
 
   // Invalid codec format.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_dot_codec(), kExternal));
 
   // Non-container2 codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, vp8_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, unknown_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, mixed_codecs(), kExternal));
 
   // Valid audio types.
   EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, fooaudio_codec(), kExternal));
 
-  // Valid audio types - parent key system.
-  // Prefixed has parent key system support.
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, no_codecs(), kExternalParent));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, fooaudio_codec(), kExternalParent));
-
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, foovideo_codec(), kExternal));
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, foovideo_and_fooaudio_codecs(), kExternal));
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, vorbis_codec(), kExternal));
 }
 
 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(IsSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystem(kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternal));
 
   UpdateClientKeySystems();
 
   EXPECT_TRUE(IsSupportedKeySystem(kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystem(kExternal));
 }
 
-TEST_F(KeySystemsTest, PrefixedKeySystemsUpdate) {
-  EXPECT_TRUE(IsSupportedKeySystem(kUsesAes));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystem(kExternal));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
-
-  UpdateClientKeySystems();
-
-  EXPECT_TRUE(IsSupportedKeySystem(kUsesAes));
-  EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAes));
-  EXPECT_FALSE(IsSupportedKeySystem(kExternal));
-  EXPECT_FALSE(PrefixedIsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternal));
-}
-
 TEST_F(KeySystemsPotentiallySupportedNamesTest, PotentiallySupportedNames) {
   EXPECT_FALSE(IsSupportedKeySystem("org.w3"));
   EXPECT_FALSE(IsSupportedKeySystem("org.w3."));
   EXPECT_FALSE(IsSupportedKeySystem("org.w3.clearke"));
   EXPECT_TRUE(IsSupportedKeySystem("org.w3.clearkey"));
   EXPECT_FALSE(IsSupportedKeySystem("org.w3.clearkeys"));
 
   EXPECT_FALSE(IsSupportedKeySystem("com.widevine"));
   EXPECT_FALSE(IsSupportedKeySystem("com.widevine."));
   EXPECT_FALSE(IsSupportedKeySystem("com.widevine.alph"));
@@ skipping 20 matching lines @@
   EXPECT_FALSE(IsSupportedKeySystem("com.chromecast.something.else"));
   EXPECT_FALSE(IsSupportedKeySystem("com.chromecast.other"));
 
   EXPECT_FALSE(IsSupportedKeySystem("x-"));
   EXPECT_TRUE(IsSupportedKeySystem("x-something"));
   EXPECT_FALSE(IsSupportedKeySystem("x-something.else"));
   EXPECT_FALSE(IsSupportedKeySystem("x-other"));
 }
 
 }  // namespace media