Refactor IsSupportedKeySystemWithMediaMimeType().

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
+
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "media/base/eme_constants.h"
 #include "media/base/key_system_info.h"
 #include "media/base/key_systems.h"
 #include "media/base/media_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 42 matching lines @@
   TEST_CODEC_FOO_AUDIO = 1 << 10,  // An audio codec for foo container.
   TEST_CODEC_FOO_AUDIO_ALL = TEST_CODEC_FOO_AUDIO,
   TEST_CODEC_FOO_VIDEO = 1 << 11,  // A video codec for foo container.
   TEST_CODEC_FOO_VIDEO_ALL = TEST_CODEC_FOO_VIDEO,
   TEST_CODEC_FOO_ALL = TEST_CODEC_FOO_AUDIO_ALL | TEST_CODEC_FOO_VIDEO_ALL
 };
 
 static_assert((TEST_CODEC_FOO_ALL & EME_CODEC_ALL) == EME_CODEC_NONE,
               "test codec masks should only use invalid codec masks");
 
+// Adapt IsSupportedKeySystemWithMediaMimeType() to the new API,
+// IsSupportedCodecCombination().
+static bool IsSupportedKeySystemWithMediaMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs,
+    const std::string& key_system) {
+  return KeySystems::GetInstance().IsSupportedCodecCombination(
+      key_system, EmeMediaType::VIDEO, mime_type, codecs);
+}
+
+static bool IsSupportedKeySystemWithAudioMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs,
+    const std::string& key_system) {
+  return KeySystems::GetInstance().IsSupportedCodecCombination(
+      key_system, EmeMediaType::AUDIO, mime_type, codecs);
+}
+
 // Adds test container and codec masks.
 // This function must be called after SetMediaClient() if a MediaClient will be
 // provided.
 // More details: AddXxxMask() will create KeySystems if it hasn't been created.
 // During KeySystems's construction GetMediaClient() will be used to add key
 // systems. In test code, the MediaClient is set by SetMediaClient().
 // Therefore, SetMediaClient() must be called before this function to make sure
 // MediaClient in effect when constructing KeySystems.
 static void AddContainerAndCodecMasksForTest() {
   // Since KeySystems is a singleton. Make sure we only add test container and
   // codec masks once per process.
   static bool is_test_masks_added = false;
 
   if (is_test_masks_added)
     return;
 
   AddContainerMask("audio/foo", TEST_CODEC_FOO_AUDIO_ALL);
   AddContainerMask("video/foo", TEST_CODEC_FOO_ALL);
-  AddCodecMask("fooaudio", TEST_CODEC_FOO_AUDIO);
-  AddCodecMask("foovideo", TEST_CODEC_FOO_VIDEO);
+  AddCodecMask(EmeMediaType::AUDIO, "fooaudio", TEST_CODEC_FOO_AUDIO);
+  AddCodecMask(EmeMediaType::VIDEO, "foovideo", TEST_CODEC_FOO_VIDEO);
 
   is_test_masks_added = true;
 }
 
 class TestMediaClient : public MediaClient {
  public:
   TestMediaClient();
   ~TestMediaClient() override;
 
   // MediaClient implementation.
@@ skipping 122 matching lines @@
 
   ~KeySystemsPotentiallySupportedNamesTest() override {
     // Clear the use of |test_media_client_|, which was set in SetUp().
     SetMediaClient(nullptr);
   }
 
  private:
   PotentiallySupportedNamesTestMediaClient test_media_client_;
 };
 
-// TODO(sandersd): Refactor. http://crbug.com/417444
 class KeySystemsTest : public testing::Test {
  protected:
   KeySystemsTest() {
     vp8_codec_.push_back("vp8");
 
     vp80_codec_.push_back("vp8.0");
 
     vp9_codec_.push_back("vp9");
 
     vp90_codec_.push_back("vp9.0");
@@ skipping 91 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(IsSupportedKeySystem(std::string()));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), std::string()));
   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_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kPrefixedClearKey));
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kPrefixedClearKey));
 }
 
 TEST_F(KeySystemsTest, ClearKeyWithInitDataType) {
   EXPECT_TRUE(IsSupportedKeySystem(kClearKey));
   EXPECT_TRUE(IsSupportedKeySystemWithInitDataType(kClearKey, "webm"));
   EXPECT_TRUE(IsSupportedKeySystemWithInitDataType(kClearKey, "keyids"));
 
   // All other InitDataTypes are not supported.
   EXPECT_FALSE(IsSupportedKeySystemWithInitDataType(kClearKey, "unknown"));
 }
 
 // The key system is not registered and therefore is unrecognized.
 TEST_F(KeySystemsTest, Basic_UnrecognizedKeySystem) {
   static const char* const kUnrecognized = "x-org.example.unrecognized";
 
   EXPECT_FALSE(IsSupportedKeySystem(kUnrecognized));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUnrecognized));
 
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kUnrecognized));
 
   bool can_use = false;
   EXPECT_DEBUG_DEATH_PORTABLE(
       can_use = CanUseAesDecryptor(kUnrecognized),
       "x-org.example.unrecognized is not a known concrete system");
   EXPECT_FALSE(can_use);
 
 #if defined(ENABLE_PEPPER_CDMS)
@@ skipping 23 matching lines @@
 }
 
 TEST_F(KeySystemsTest,
        IsSupportedKeySystemWithMediaMimeType_UsesAesDecryptor_TypesContainer1) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_codec(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp80_codec(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp9_codec(), kUsesAes));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp90_codec(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+
+  // Audio in a video container.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp8_and_vorbis_codecs(), kUsesAes));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp9_and_vorbis_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vorbis_codec(), kUsesAes));
 
   // Non-Webm codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, foovideo_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, unknown_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, mixed_codecs(), kUsesAes));
 
   // Valid audio types.
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, no_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vorbis_codec(), kUsesAes));
 
   // Non-audio codecs.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp8_and_vorbis_codecs(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp9_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kAudioWebM, vp9_and_vorbis_codecs(), kUsesAes));
 
   // Non-Webm codec.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, fooaudio_codec(), kUsesAes));
 }
 
 // No parent is registered for UsesAes.
 TEST_F(KeySystemsTest, Parent_NoParentRegistered) {
   EXPECT_FALSE(IsSupportedKeySystem(kUsesAesParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kUsesAesParent));
 
   // The parent is not supported for most things.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kUsesAesParent));
   bool result = false;
   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kUsesAesParent),
                               "x-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),
                      "x-org.example is not a known concrete system");
   EXPECT_TRUE(type.empty());
 #endif
 }
 
 TEST_F(KeySystemsTest, IsSupportedKeySystem_InvalidVariants) {
   // Case sensitive.
   EXPECT_FALSE(IsSupportedKeySystem("x-org.example.ClEaR"));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(kVideoWebM, no_codecs(),
-                                                     "x-org.example.ClEaR"));
 
   // TLDs are not allowed.
   EXPECT_FALSE(IsSupportedKeySystem("org."));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "org."));
   EXPECT_FALSE(IsSupportedKeySystem("com"));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "com"));
 
   // Extra period.
   EXPECT_FALSE(IsSupportedKeySystem("x-org.example.clear."));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(kVideoWebM, no_codecs(),
-                                                     "x-org.example.clear."));
   EXPECT_FALSE(IsSupportedKeySystem("x-org.example."));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(kVideoWebM, no_codecs(),
-                                                     "x-org.example."));
 
   // Incomplete.
   EXPECT_FALSE(IsSupportedKeySystem("x-org.example.clea"));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(kVideoWebM, no_codecs(),
-                                                     "x-org.example.clea"));
 
   // Extra character.
   EXPECT_FALSE(IsSupportedKeySystem("x-org.example.clearz"));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(kVideoWebM, no_codecs(),
-                                                     "x-org.example.clearz"));
 
   // There are no child key systems for UsesAes.
   EXPECT_FALSE(IsSupportedKeySystem("x-org.example.clear.foo"));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), "x-org.example.clear.foo"));
 }
 
 TEST_F(KeySystemsTest, IsSupportedKeySystemWithMediaMimeType_NoType) {
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       std::string(), no_codecs(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       std::string(), no_codecs(), kUsesAesParent));
 
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(std::string(), no_codecs(),
                                                      "x-org.example.foo"));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       std::string(), no_codecs(), "x-org.example.clear.foo"));
 }
 
 // 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));
-  // The parent should be supported but is not. See http://crbug.com/164303.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kUsesAesParent));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_codec(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+
+  // Audio in a video container.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_and_fooaudio_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, fooaudio_codec(), kUsesAes));
 
   // Extended codecs fail because this is handled by SimpleWebMimeRegistryImpl.
   // They should really pass canPlayType().
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_extended_codec(), kUsesAes));
 
   // Invalid codec format.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_dot_codec(), kUsesAes));
 
   // Non-container2 codec.
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, vp8_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, unknown_codec(), kUsesAes));
   EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, mixed_codecs(), kUsesAes));
 
   // Valid audio types.
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, no_codecs(), kUsesAes));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, fooaudio_codec(), kUsesAes));
 
   // Non-audio codecs.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, foovideo_codec(), kUsesAes));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, foovideo_and_fooaudio_codecs(), kUsesAes));
 
   // Non-container2 codec.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, vorbis_codec(), kUsesAes));
 }
 
 //
 // Non-AesDecryptor-based key system.
 //
 
 TEST_F(KeySystemsTest, Basic_ExternalDecryptor) {
   EXPECT_TRUE(IsSupportedKeySystem(kExternal));
   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) {
-  // The parent system is not a concrete system but is supported.
+  // Unprefixed has no parent key system support.
   EXPECT_FALSE(IsSupportedKeySystem(kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternalParent));
   EXPECT_TRUE(PrefixedIsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, no_codecs(), kExternalParent));
 
   // The parent is not supported for most things.
   EXPECT_EQ("Unknown", GetKeySystemNameForUMA(kExternalParent));
   bool result = false;
   EXPECT_DEBUG_DEATH_PORTABLE(result = CanUseAesDecryptor(kExternalParent),
                               "x-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),
                      "x-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));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp8_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp80_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp9_codec(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp90_codec(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+
+  // Audio in a video container.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+      kVideoWebM, vp8_and_vorbis_codecs(), kExternal));
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vp9_and_vorbis_codecs(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoWebM, vorbis_codec(), kExternal));
 
   // Valid video types - parent key system.
-  // Unprefixed has no parent key system support.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_codec(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp80_codec(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp8_and_vorbis_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_codec(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp90_codec(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vp9_and_vorbis_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, vorbis_codec(), kExternalParent));
   // 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(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, no_codecs(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vorbis_codec(), kExternal));
 
   // Valid audio types - parent key system.
-  // Unprefixed has no parent key system support.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, no_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioWebM, vorbis_codec(), kExternalParent));
   // 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(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp8_codec(), kExternal));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp8_and_vorbis_codecs(), kExternal));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp9_codec(), kExternal));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, vp9_and_vorbis_codecs(), kExternal));
 
   // Non-Webm codec.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioWebM, fooaudio_codec(), kExternal));
 }
 
 TEST_F(
     KeySystemsTest,
     IsSupportedKeySystemWithMediaMimeType_ExternalDecryptor_TypesContainer2) {
   // Valid video types.
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, no_codecs(), kExternal));
   EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_codec(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+
+  // Audio in a video container.
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, foovideo_and_fooaudio_codecs(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
       kVideoFoo, fooaudio_codec(), kExternal));
 
   // Valid video types - parent key system.
-  // Unprefixed has no parent key system support.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, no_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_codec(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, foovideo_and_fooaudio_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoFoo, fooaudio_codec(), kExternalParent));
   // 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(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, no_codecs(), kExternal));
-  EXPECT_TRUE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_TRUE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, fooaudio_codec(), kExternal));
 
   // Valid audio types - parent key system.
-  // Unprefixed has no parent key system support.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, no_codecs(), kExternalParent));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kAudioFoo, fooaudio_codec(), kExternalParent));
   // 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(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, foovideo_codec(), kExternal));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  EXPECT_FALSE(IsSupportedKeySystemWithAudioMimeType(
       kAudioFoo, foovideo_and_fooaudio_codecs(), kExternal));
 
   // Non-container2 codec.
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
+  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));
-  EXPECT_FALSE(IsSupportedKeySystemWithMediaMimeType(
-      kVideoWebM, no_codecs(), 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));
 
@@ skipping 40 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