Move KeySystemInfo to media.

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/common/eme_constants.h"
 #include "content/public/renderer/content_renderer_client.h"
-#include "content/public/renderer/key_system_info.h"
 #include "content/renderer/media/crypto/key_systems.h"
 #include "content/test/test_content_client.h"
+#include "media/base/eme_constants.h"
+#include "media/base/key_system_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 #include "widevine_cdm_version.h"  // In SHARED_INTERMEDIATE_DIR.
 
 // Death tests are not always available, including on Android.
 // EXPECT_DEBUG_DEATH_PORTABLE executes tests correctly except in the case that
 // death tests are not available and NDEBUG is not defined.
 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 #define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
   EXPECT_DEBUG_DEATH(statement, regex)
 #else
 #if defined(NDEBUG)
 #define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
   do { statement; } while (false)
 #else
 #include "base/logging.h"
 #define EXPECT_DEBUG_DEATH_PORTABLE(statement, regex) \
   LOG(WARNING) << "Death tests are not supported on this platform.\n" \
                << "Statement '" #statement "' cannot be verified.";
 #endif  // defined(NDEBUG)
 #endif  // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 
 namespace content {
 
 using blink::WebString;
+using media::KeySystemInfo;
 
 // These are the (fake) key systems that are registered for these tests.
 // kUsesAes uses the AesDecryptor like Clear Key.
 // kExternal uses an external CDM, such as Pepper-based or Android platform CDM.
 const char kUsesAes[] = "org.example.clear";
 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 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 {
   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
 };
 
-COMPILE_ASSERT((TEST_CODEC_FOO_ALL & EME_CODEC_ALL) == EME_CODEC_NONE,
-                test_codec_masks_should_only_use_invalid_codec_masks);
+COMPILE_ASSERT((TEST_CODEC_FOO_ALL & media::EME_CODEC_ALL) ==
+                   media::EME_CODEC_NONE,
+               test_codec_masks_should_only_use_invalid_codec_masks);
 
 // 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", TEST_CODEC_FOO_AUDIO_ALL);
   AddContainerMask("video/foo", TEST_CODEC_FOO_ALL);
   AddCodecMask("fooaudio", TEST_CODEC_FOO_AUDIO);
   AddCodecMask("foovideo", TEST_CODEC_FOO_VIDEO);
 
   is_test_masks_added = true;
 }
 
 class TestContentRendererClient : public ContentRendererClient {
-  void AddKeySystems(std::vector<content::KeySystemInfo>* key_systems) override;
+  void AddKeySystems(std::vector<media::KeySystemInfo>* key_systems) override;
 };
 
 void TestContentRendererClient::AddKeySystems(
-    std::vector<content::KeySystemInfo>* key_systems) {
+    std::vector<media::KeySystemInfo>* key_systems) {
   KeySystemInfo aes(kUsesAes);
-  aes.supported_codecs = EME_CODEC_WEBM_ALL;
+  aes.supported_codecs = media::EME_CODEC_WEBM_ALL;
   aes.supported_codecs |= TEST_CODEC_FOO_ALL;
-  aes.supported_init_data_types = EME_INIT_DATA_TYPE_WEBM;
+  aes.supported_init_data_types = media::EME_INIT_DATA_TYPE_WEBM;
   aes.use_aes_decryptor = true;
   key_systems->push_back(aes);
 
   KeySystemInfo ext(kExternal);
-  ext.supported_codecs = EME_CODEC_WEBM_ALL;
+  ext.supported_codecs = media::EME_CODEC_WEBM_ALL;
   ext.supported_codecs |= TEST_CODEC_FOO_ALL;
-  ext.supported_init_data_types = EME_INIT_DATA_TYPE_WEBM;
+  ext.supported_init_data_types = media::EME_INIT_DATA_TYPE_WEBM;
   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);
 }
 
 // TODO(sandersd): Refactor. http://crbug.com/417444
 class KeySystemsTest : public testing::Test {
  protected:
@@ skipping 519 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