media: Add a central place for clear key related information

Moved clear key related constants to `clear_key_cdm_common.h`:
- Clear Key key system ("org.w3.clearkey")
- External Clear Key key system ("org.chromium.externalclearkey")
and variants
- kClearKeyCdmXXX and CdmType constants

Bug: 764480
Change-Id: Ic759a215ec9636b0272f2a3d8c24b32f29ae885e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4178990
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Yuchen Liu <yucliu@chromium.org>
Commit-Queue: Sangbaek Park <sangbaekpark@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1096899}

chrome/browser/DEPS

@@ -397,8 +397,7 @@ include_rules = [
   "+media/audio", # For media audio hang monitor.
   "+media/base",  # For media switches
   "+media/capabilities", # For InMemoryVideoDecodeStatsDB
-  "+media/cdm/cdm_paths.h",
-  "+media/cdm/win/media_foundation_cdm.h",
+  "+media/cdm",
   "+media/remoting/device_capability_checker.h",
   "+media/capture",
   "+media/midi",  # For midi switches

chrome/browser/load_library_perf_test.cc

@@ -20,6 +20,7 @@
 
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
 #include "media/cdm/cdm_paths.h"
+#include "media/cdm/clear_key_cdm_common.h"
 #endif
 
 namespace {

chrome/browser/media/DEPS

@@ -4,8 +4,7 @@ include_rules = [
   "+media/audio",
   "+media/base",
   "+media/cast",
-  "+media/cdm/media_foundation_cdm_data.h",
-  "+media/cdm/supported_cdm_versions.h",
+  "+media/cdm",
   "+media/media_buildflags.h",
   "+media/mojo/mojom",
   # safe_dial_device_description_parser_unittest.cc needs DataDecoderService.

chrome/browser/media/encrypted_media_browsertest.cc

@@ -32,6 +32,7 @@
 #include "media/base/key_system_names.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
+#include "media/cdm/clear_key_cdm_common.h"
 #include "media/cdm/supported_cdm_versions.h"
 #include "media/media_buildflags.h"
 #include "testing/gtest/include/gtest/gtest-spi.h"
@@ -44,35 +45,11 @@
 
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
 #include "chrome/browser/media/library_cdm_test_helper.h"
-#include "media/cdm/cdm_paths.h"
 #endif
 
-// Available key systems.
-const char kClearKeyKeySystem[] = "org.w3.clearkey";
-const char kExternalClearKeyKeySystem[] = "org.chromium.externalclearkey";
-
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
-// Variants of External Clear Key key system to test different scenarios.
-// To add a new variant, make sure you also update:
-// - media/test/data/eme_player_js/globals.js
-// - media/test/data/eme_player_js/player_utils.js
-// - CreateCdmInstance() in clear_key_cdm.cc
-const char kExternalClearKeyMessageTypeTestKeySystem[] =
-    "org.chromium.externalclearkey.messagetypetest";
-const char kExternalClearKeyFileIOTestKeySystem[] =
-    "org.chromium.externalclearkey.fileiotest";
 const char kExternalClearKeyInitializeFailKeySystem[] =
     "org.chromium.externalclearkey.initializefail";
-const char kExternalClearKeyPlatformVerificationTestKeySystem[] =
-    "org.chromium.externalclearkey.platformverificationtest";
-const char kExternalClearKeyCrashKeySystem[] =
-    "org.chromium.externalclearkey.crash";
-#if BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
-const char kExternalClearKeyVerifyCdmHostTestKeySystem[] =
-    "org.chromium.externalclearkey.verifycdmhosttest";
-#endif  // BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
-const char kExternalClearKeyStorageIdTestKeySystem[] =
-    "org.chromium.externalclearkey.storageidtest";
 #endif  // BUILDFLAG(ENABLE_LIBRARY_CDMS)
 
 // Sessions to load.
@@ -124,9 +101,10 @@ enum class PlayCount { ONCE, TWICE };
 class EncryptedMediaTestBase : public MediaBrowserTest {
  public:
   bool IsExternalClearKey(const std::string& key_system) {
-    if (key_system == kExternalClearKeyKeySystem)
+    if (key_system == media::kExternalClearKeyKeySystem) {
       return true;
-    std::string prefix = std::string(kExternalClearKeyKeySystem) + '.';
+    }
+    std::string prefix = std::string(media::kExternalClearKeyKeySystem) + '.';
     return key_system.substr(0, prefix.size()) == prefix;
   }
 
@@ -340,7 +318,7 @@ class ECKEncryptedMediaTest : public EncryptedMediaTestBase,
   int GetCdmInterfaceVersion() { return GetParam(); }
 
   // We use special |key_system| names to do non-playback related tests,
-  // e.g. kExternalClearKeyFileIOTestKeySystem is used to test file IO.
+  // e.g. media::kExternalClearKeyFileIOTestKeySystem is used to test file IO.
   void TestNonPlaybackCases(const std::string& key_system,
                             const std::string& expected_title) {
     // Since we do not test playback, arbitrarily choose a test file and source
@@ -361,7 +339,8 @@ class ECKEncryptedMediaTest : public EncryptedMediaTestBase,
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
+    SetUpCommandLineForKeySystem(media::kExternalClearKeyKeySystem,
+                                 command_line);
     // Override enabled CDM interface version for testing.
     command_line->AppendSwitchASCII(
         switches::kOverrideEnabledCdmInterfaceVersion,
@@ -395,7 +374,8 @@ class ECKEncryptedMediaOutputProtectionTest
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
+    SetUpCommandLineForKeySystem(media::kExternalClearKeyKeySystem,
+                                 command_line);
     // The output protection tests create a MediaRecorder on a MediaStream,
     // so this allows for a fake stream to be created.
     command_line->AppendSwitch(switches::kUseFakeUIForMediaStream);
@@ -408,7 +388,7 @@ class ECKEncryptedMediaOutputProtectionTest
 class ECKIncognitoEncryptedMediaTest : public EncryptedMediaTestBase {
  public:
   // We use special |key_system| names to do non-playback related tests,
-  // e.g. kExternalClearKeyFileIOTestKeySystem is used to test file IO.
+  // e.g. media::kExternalClearKeyFileIOTestKeySystem is used to test file IO.
   void TestNonPlaybackCases(const std::string& key_system,
                             const std::string& expected_title) {
     // Since we do not test playback, arbitrarily choose a test file and source
@@ -421,7 +401,8 @@ class ECKIncognitoEncryptedMediaTest : public EncryptedMediaTestBase {
  protected:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     EncryptedMediaTestBase::SetUpCommandLine(command_line);
-    SetUpCommandLineForKeySystem(kExternalClearKeyKeySystem, command_line);
+    SetUpCommandLineForKeySystem(media::kExternalClearKeyKeySystem,
+                                 command_line);
     command_line->AppendSwitch(switches::kIncognito);
   }
 };
@@ -543,34 +524,34 @@ using ::testing::Values;
 
 INSTANTIATE_TEST_SUITE_P(MSE_ClearKey,
                          EncryptedMediaTest,
-                         Combine(Values(kClearKeyKeySystem),
+                         Combine(Values(media::kClearKeyKeySystem),
                                  Values(SrcType::MSE)));
 
 INSTANTIATE_TEST_SUITE_P(MSE_ClearKey,
                          MseEncryptedMediaTest,
-                         Values(kClearKeyKeySystem));
+                         Values(media::kClearKeyKeySystem));
 
 // External Clear Key is currently only used on platforms that use library CDMs.
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
 INSTANTIATE_TEST_SUITE_P(SRC_ExternalClearKey,
                          EncryptedMediaTest,
-                         Combine(Values(kExternalClearKeyKeySystem),
+                         Combine(Values(media::kExternalClearKeyKeySystem),
                                  Values(SrcType::SRC)));
 
 INSTANTIATE_TEST_SUITE_P(MSE_ExternalClearKey,
                          EncryptedMediaTest,
-                         Combine(Values(kExternalClearKeyKeySystem),
+                         Combine(Values(media::kExternalClearKeyKeySystem),
                                  Values(SrcType::MSE)));
 
 INSTANTIATE_TEST_SUITE_P(MSE_ExternalClearKey,
                          MseEncryptedMediaTest,
-                         Values(kExternalClearKeyKeySystem));
+                         Values(media::kExternalClearKeyKeySystem));
 #else   // BUILDFLAG(ENABLE_LIBRARY_CDMS)
 // To reduce test time, only run ClearKey SRC tests when we are not running
 // ExternalClearKey SRC tests.
 INSTANTIATE_TEST_SUITE_P(SRC_ClearKey,
                          EncryptedMediaTest,
-                         Combine(Values(kClearKeyKeySystem),
+                         Combine(Values(media::kClearKeyKeySystem),
                                  Values(SrcType::SRC)));
 #endif  // BUILDFLAG(ENABLE_LIBRARY_CDMS)
 
@@ -583,7 +564,7 @@ INSTANTIATE_TEST_SUITE_P(MSE_Widevine,
 INSTANTIATE_TEST_SUITE_P(MSE_Widevine,
                          MseEncryptedMediaTest,
                          Values(kWidevineKeySystem));
-#endif  // #if BUILDFLAG(BUNDLE_WIDEVINE_CDM)
+#endif  // BUILDFLAG(BUNDLE_WIDEVINE_CDM)
 
 IN_PROC_BROWSER_TEST_P(EncryptedMediaTest, Playback_AudioClearVideo_WebM) {
   TestSimplePlayback("bear-320x240-av_enc-a.webm");
@@ -825,17 +806,19 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, InitializeCDMFail) {
 // When CDM crashes, we should still get a decode error and all sessions should
 // be closed.
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, MAYBE_CDMCrashDuringDecode) {
-  TestNonPlaybackCases(kExternalClearKeyCrashKeySystem,
+  TestNonPlaybackCases(media::kExternalClearKeyCrashKeySystem,
                        kEmeSessionClosedAndError);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, FileIOTest) {
-  TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem, kUnitTestSuccess);
+  TestNonPlaybackCases(media::kExternalClearKeyFileIOTestKeySystem,
+                       kUnitTestSuccess);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, PlatformVerificationTest) {
-  TestNonPlaybackCases(kExternalClearKeyPlatformVerificationTestKeySystem,
-                       kUnitTestSuccess);
+  TestNonPlaybackCases(
+      media::kExternalClearKeyPlatformVerificationTestKeySystem,
+      kUnitTestSuccess);
 }
 
 // Intermittent leaks on ASan/LSan runs: crbug.com/889923
@@ -845,8 +828,8 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, PlatformVerificationTest) {
 #define MAYBE_MessageTypeTest MessageTypeTest
 #endif
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, MAYBE_MessageTypeTest) {
-  TestPlaybackCase(kExternalClearKeyMessageTypeTestKeySystem, kNoSessionToLoad,
-                   media::kEndedTitle);
+  TestPlaybackCase(media::kExternalClearKeyMessageTypeTestKeySystem,
+                   kNoSessionToLoad, media::kEndedTitle);
 
   int num_received_message_types = 0;
   EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
@@ -861,34 +844,32 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, MAYBE_MessageTypeTest) {
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, LoadPersistentLicense) {
-  TestPlaybackCase(kExternalClearKeyKeySystem, kPersistentLicense,
+  TestPlaybackCase(media::kExternalClearKeyKeySystem, kPersistentLicense,
                    media::kEndedTitle);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, LoadUnknownSession) {
-  TestPlaybackCase(kExternalClearKeyKeySystem, kUnknownSession,
+  TestPlaybackCase(media::kExternalClearKeyKeySystem, kUnknownSession,
                    kEmeSessionNotFound);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, LoadSessionAfterClose) {
-  base::StringPairs query_params{{"keySystem", kExternalClearKeyKeySystem}};
+  base::StringPairs query_params{
+      {"keySystem", media::kExternalClearKeyKeySystem}};
   RunEncryptedMediaTestPage("eme_load_session_after_close_test.html",
-                            kExternalClearKeyKeySystem, query_params,
+                            media::kExternalClearKeyKeySystem, query_params,
                             media::kEndedTitle);
 }
 
-const char kExternalClearKeyDecryptOnlyKeySystem[] =
-    "org.chromium.externalclearkey.decryptonly";
-
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, DecryptOnly_VideoAudio_WebM) {
   RunSimpleEncryptedMediaTest("bear-320x240-av_enc-av.webm",
-                              kExternalClearKeyDecryptOnlyKeySystem,
+                              media::kExternalClearKeyDecryptOnlyKeySystem,
                               SrcType::MSE);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, DecryptOnly_VideoOnly_MP4_VP9) {
   RunSimpleEncryptedMediaTest("bear-320x240-v_frag-vp9-cenc.mp4",
-                              kExternalClearKeyDecryptOnlyKeySystem,
+                              media::kExternalClearKeyDecryptOnlyKeySystem,
                               SrcType::MSE);
 }
 
@@ -900,27 +881,27 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, DecryptOnly_VideoOnly_MP4_CBCS) {
   std::string expected_result =
       GetCdmInterfaceVersion() >= 10 ? media::kEndedTitle : media::kErrorTitle;
   RunEncryptedMediaTest(kDefaultEmePlayer, "bear-640x360-v_frag-cbcs.mp4",
-                        kExternalClearKeyDecryptOnlyKeySystem, SrcType::MSE,
-                        kNoSessionToLoad, false, PlayCount::ONCE,
+                        media::kExternalClearKeyDecryptOnlyKeySystem,
+                        SrcType::MSE, kNoSessionToLoad, false, PlayCount::ONCE,
                         expected_result);
 }
 
 // Encryption Scheme tests. ClearKey key system is covered in
 // content/browser/media/encrypted_media_browsertest.cc.
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, Playback_Encryption_CENC) {
   RunEncryptedMediaMultipleFileTest(
-      kExternalClearKeyKeySystem, "bear-640x360-v_frag-cenc.mp4",
+      media::kExternalClearKeyKeySystem, "bear-640x360-v_frag-cenc.mp4",
       "bear-640x360-a_frag-cenc.mp4", media::kEndedTitle);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, Playback_Encryption_CBC1) {
-  RunEncryptedMediaMultipleFileTest(kExternalClearKeyKeySystem,
+  RunEncryptedMediaMultipleFileTest(media::kExternalClearKeyKeySystem,
                                     "bear-640x360-v_frag-cbc1.mp4",
                                     std::string(), media::kErrorTitle);
 }
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, Playback_Encryption_CENS) {
-  RunEncryptedMediaMultipleFileTest(kExternalClearKeyKeySystem,
+  RunEncryptedMediaMultipleFileTest(media::kExternalClearKeyKeySystem,
                                     "bear-640x360-v_frag-cens.mp4",
                                     std::string(), media::kErrorTitle);
 }
@@ -931,21 +912,21 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, Playback_Encryption_CBCS) {
   std::string expected_result =
       GetCdmInterfaceVersion() >= 10 ? media::kEndedTitle : media::kErrorTitle;
   RunEncryptedMediaMultipleFileTest(
-      kExternalClearKeyKeySystem, "bear-640x360-v_frag-cbcs.mp4",
+      media::kExternalClearKeyKeySystem, "bear-640x360-v_frag-cbcs.mp4",
       "bear-640x360-a_frag-cbcs.mp4", expected_result);
 }
 
 #endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 
 #if BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, VerifyCdmHostTest) {
-  TestNonPlaybackCases(kExternalClearKeyVerifyCdmHostTestKeySystem,
+  TestNonPlaybackCases(media::kExternalClearKeyVerifyCdmHostTestKeySystem,
                        kUnitTestSuccess);
 }
 #endif  // BUILDFLAG(ENABLE_CDM_HOST_VERIFICATION)
 
 IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaTest, StorageIdTest) {
-  TestNonPlaybackCases(kExternalClearKeyStorageIdTestKeySystem,
+  TestNonPlaybackCases(media::kExternalClearKeyStorageIdTestKeySystem,
                        kUnitTestSuccess);
 }
 
@@ -992,14 +973,16 @@ IN_PROC_BROWSER_TEST_P(ECKEncryptedMediaOutputProtectionTest, AfterMediaKeys) {
 
 IN_PROC_BROWSER_TEST_F(ECKIncognitoEncryptedMediaTest, FileIO) {
   // Try the FileIO test using the default CDM API while running in incognito.
-  TestNonPlaybackCases(kExternalClearKeyFileIOTestKeySystem, kUnitTestSuccess);
+  TestNonPlaybackCases(media::kExternalClearKeyFileIOTestKeySystem,
+                       kUnitTestSuccess);
 }
 
 IN_PROC_BROWSER_TEST_F(ECKIncognitoEncryptedMediaTest, LoadSessionAfterClose) {
   // Loading a session should work in incognito mode.
-  base::StringPairs query_params{{"keySystem", kExternalClearKeyKeySystem}};
+  base::StringPairs query_params{
+      {"keySystem", media::kExternalClearKeyKeySystem}};
   RunEncryptedMediaTestPage("eme_load_session_after_close_test.html",
-                            kExternalClearKeyKeySystem, query_params,
+                            media::kExternalClearKeyKeySystem, query_params,
                             media::kEndedTitle);
 }
 #endif  // BUILDFLAG(ENABLE_LIBRARY_CDMS)

chrome/browser/media/encrypted_media_supported_types_browsertest.cc

@@ -31,14 +31,14 @@
 #include "content/public/test/browser_test_utils.h"
 #include "media/base/media_switches.h"
 #include "media/base/test_data_util.h"
+#include "media/cdm/clear_key_cdm_common.h"
 #include "media/media_buildflags.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "third_party/widevine/cdm/buildflags.h"
 #include "url/gurl.h"
 
 #if BUILDFLAG(ENABLE_LIBRARY_CDMS)
 #include "chrome/browser/media/library_cdm_test_helper.h"
-#include "media/cdm/cdm_paths.h"
 #endif
 
 #if BUILDFLAG(IS_ANDROID)
@@ -47,8 +47,9 @@
 
 namespace {
 
-const char kClearKey[] = "org.w3.clearkey";
-const char kExternalClearKey[] = "org.chromium.externalclearkey";
+const char* kClearKey = media::kClearKeyKeySystem;
+const char* kExternalClearKey = media::kExternalClearKeyKeySystem;
+
 const char kWidevine[] = "com.widevine.alpha";
 const char kWidevineExperiment[] = "com.widevine.alpha.experiment";
 

chrome/browser/media/library_cdm_test_helper.cc

@@ -12,6 +12,7 @@
 #include "base/path_service.h"
 #include "media/base/media_switches.h"
 #include "media/cdm/cdm_paths.h"
+#include "media/cdm/clear_key_cdm_common.h"
 
 void RegisterClearKeyCdm(base::CommandLine* command_line,
                          bool use_wrong_cdm_path) {