Store SupportedCodecs in KeySystemInfo and KeySystems.

content/renderer/media/crypto/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 "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/key_system_info.h"
@@ skipping 31 matching lines @@
 const char kUsesAesParent[] = "org.example";  // Not registered.
 const char kExternal[] = "com.example.test";
 const char kExternalParent[] = "com.example";
 
 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 kVorbis[] = "vorbis";
-const char kVP8[] = "vp8";
-const char kVP80[] = "vp8.0";
-
 const char kAudioFoo[] = "audio/foo";
 const char kVideoFoo[] = "video/foo";
-const char kFooAudioCodec[] = "fooaudio";
-const char kFooVideoCodec[] = "foovideo";
+
+enum TestCodecMask {
+  FOO_AUDIO_CODEC = 1 << 10,

[ddorwin, 2014/04/22 21:24:41]

Is there significance to 10?

[xhwang, 2014/04/23 17:29:14]

Added a comment.

+  FOO_AUDIO = FOO_AUDIO_CODEC,
+  FOO_VIDEO_CODEC = 1 << 11,
+  FOO_VIDEO = FOO_VIDEO_CODEC,
+  FOO_CODECS = FOO_AUDIO | FOO_VIDEO
+};
+
+COMPILE_ASSERT((FOO_CODECS & media::ALL_CODECS) == media::NO_CODECS,

[ddorwin, 2014/04/22 21:24:41]

Maybe we should just remove some PROPRIETARY_CODECS checks in the enums but
still prevent them from being used externally. Then we wouldn't need foo, the
additional methods, etc. WDYT?

[xhwang, 2014/04/23 17:29:14]

I am not sure what you exactly mean...

+               "Test codec masks should only use invalid codec masks.");
 
 namespace content {
 
+// Adds test container and codec masks.
+// This function must be called after SetContentClient() is called.
+// More details: AddXxxMask() will create KeySystems if it hasn't been created.
+// During KeySystems's construction GetContentClient() will be used to add key
+// systems. In test code, the content client is set by SetContentClient().
+// Therefore, SetContentClient() must be called before this function to avoid
+// access violation.
+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", FOO_AUDIO);
+  AddContainerMask("video/foo", FOO_CODECS);
+  AddCodecMask("fooaudio", FOO_AUDIO_CODEC);
+  AddCodecMask("foovideo", FOO_VIDEO_CODEC);
+
+  is_test_masks_added = true;
+}
+
 class TestContentRendererClient : public ContentRendererClient {
   virtual void AddKeySystems(
       std::vector<content::KeySystemInfo>* key_systems) OVERRIDE;
 };
 
 void TestContentRendererClient::AddKeySystems(
     std::vector<content::KeySystemInfo>* key_systems) {
   KeySystemInfo aes(kUsesAes);
-
-  aes.supported_types[kAudioWebM].insert(kVorbis);
-  aes.supported_types[kVideoWebM] = aes.supported_types[kAudioWebM];
-  aes.supported_types[kVideoWebM].insert(kVP8);
-  aes.supported_types[kVideoWebM].insert(kVP80);
-  aes.supported_types[kAudioFoo].insert(kFooAudioCodec);
-  aes.supported_types[kVideoFoo] = aes.supported_types[kAudioFoo];
-  aes.supported_types[kVideoFoo].insert(kFooVideoCodec);
-
+  aes.supported_codecs = media::WEBM_CODECS;
+  aes.supported_codecs |= FOO_CODECS;
   aes.use_aes_decryptor = true;
-
   key_systems->push_back(aes);
 
   KeySystemInfo ext(kExternal);
-
-  ext.supported_types[kAudioWebM].insert(kVorbis);
-  ext.supported_types[kVideoWebM] = ext.supported_types[kAudioWebM];
-  ext.supported_types[kVideoWebM].insert(kVP8);
-  ext.supported_types[kVideoWebM].insert(kVP80);
-  ext.supported_types[kAudioFoo].insert(kFooAudioCodec);
-  ext.supported_types[kVideoFoo] = ext.supported_types[kAudioFoo];
-  ext.supported_types[kVideoFoo].insert(kFooVideoCodec);
-
+  ext.supported_codecs = media::WEBM_CODECS;
+  ext.supported_codecs |= FOO_CODECS;
   ext.parent_key_system = kExternalParent;
-
 #if defined(ENABLE_PEPPER_CDMS)
   ext.pepper_type = "application/x-ppapi-external-cdm";
 #endif  // defined(ENABLE_PEPPER_CDMS)
-
   key_systems->push_back(ext);
 }
 
 class KeySystemsTest : public testing::Test {
  protected:
   KeySystemsTest() {
     vp8_codec_.push_back("vp8");
 
     vp80_codec_.push_back("vp8.0");
 
@@ skipping 22 matching lines @@
     // The TestContentClient is not available inside Death Tests on some
     // platforms (see below). Therefore, always provide a TestContentClient.
     // Explanation: When Death Tests fork, there is a valid ContentClient.
     // However, when they launch a new process instead of forking, the global
     // variable is not copied and for some reason TestContentClientInitializer
     // does not get created to set the global variable in the new process.
     SetContentClient(&test_content_client_);
     SetRendererClientForTesting(&content_renderer_client_);
   }
 
+  virtual void SetUp() OVERRIDE {
+    AddContainerAndCodecMasksForTest();
+  }
+
   virtual ~KeySystemsTest() {
     // Clear the use of content_client_, which was set in SetUp().
     SetContentClient(NULL);
   }
 
   typedef std::vector<std::string> CodecVector;
 
   const CodecVector& no_codecs() const { return no_codecs_; }
 
   const CodecVector& vp8_codec() const { return vp8_codec_; }
@@ skipping 426 matching lines @@
 
 #if defined(WIDEVINE_CDM_AVAILABLE)
   const char* const kTestWidevineUmaName = "Widevine";
 #else
   const char* const kTestWidevineUmaName = "Unknown";
 #endif
   EXPECT_EQ(kTestWidevineUmaName, KeySystemNameForUMA("com.widevine.alpha"));
 }
 
 }  // namespace content