media: Rename MediaKeys to ContentDecryptionModule

media/cdm/json_web_key_unittest.cc

Index: media/cdm/json_web_key_unittest.cc
diff --git a/media/cdm/json_web_key_unittest.cc b/media/cdm/json_web_key_unittest.cc
index 0fd4a82ab71f6dddf8c9b4e401733cca4ba5ef1b..074265a661d18ffa78cd2aeedc084105fd9ec33e 100644
--- a/media/cdm/json_web_key_unittest.cc
+++ b/media/cdm/json_web_key_unittest.cc
@@ -10,6 +10,7 @@
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "media/base/content_decryption_module.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
@@ -24,18 +25,19 @@ class JSONWebKeyTest : public testing::Test {
                                size_t expected_number_of_keys) {
     DCHECK(!jwk.empty());
     KeyIdAndKeyPairs keys;
-    MediaKeys::SessionType session_type;
+    ContentDecryptionModule::SessionType session_type;
     EXPECT_EQ(expected_result,
               ExtractKeysFromJWKSet(jwk, &keys, &session_type));
     EXPECT_EQ(expected_number_of_keys, keys.size());
   }
 
-  void ExtractSessionTypeAndExpect(const std::string& jwk,
-                                   bool expected_result,
-                                   MediaKeys::SessionType expected_type) {
+  void ExtractSessionTypeAndExpect(
+      const std::string& jwk,
+      bool expected_result,
+      ContentDecryptionModule::SessionType expected_type) {
     DCHECK(!jwk.empty());
     KeyIdAndKeyPairs keys;
-    MediaKeys::SessionType session_type;
+    ContentDecryptionModule::SessionType session_type;
     EXPECT_EQ(expected_result,
               ExtractKeysFromJWKSet(jwk, &keys, &session_type));
     if (expected_result) {
@@ -46,7 +48,7 @@ class JSONWebKeyTest : public testing::Test {
 
   void CreateLicenseAndExpect(const uint8_t* key_id,
                               int key_id_length,
-                              MediaKeys::SessionType session_type,
+                              ContentDecryptionModule::SessionType session_type,
                               const std::string& expected_result) {
     std::vector<uint8_t> result;
     KeyIdList key_ids;
@@ -111,14 +113,15 @@ TEST_F(JSONWebKeyTest, GenerateJWKSet) {
   EXPECT_EQ(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"temporary\"}",
-      GenerateJWKSet(keys, MediaKeys::TEMPORARY_SESSION));
+      GenerateJWKSet(keys, ContentDecryptionModule::TEMPORARY_SESSION));
   keys.push_back(
       MakeKeyIdAndKeyPair(data2, arraysize(data2), data2, arraysize(data2)));
   EXPECT_EQ(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":"
       "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"}],\"type\":\"persistent-"
       "license\"}",
-      GenerateJWKSet(keys, MediaKeys::PERSISTENT_LICENSE_SESSION));
+      GenerateJWKSet(keys,
+                     ContentDecryptionModule::PERSISTENT_LICENSE_SESSION));
   keys.push_back(
       MakeKeyIdAndKeyPair(data3, arraysize(data3), data3, arraysize(data3)));
   EXPECT_EQ(
@@ -126,7 +129,8 @@ TEST_F(JSONWebKeyTest, GenerateJWKSet) {
       "\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"},{\"k\":"
       "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":"
       "\"oct\"}],\"type\":\"persistent-release-message\"}",
-      GenerateJWKSet(keys, MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION));
+      GenerateJWKSet(
+          keys, ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION));
 }
 
 TEST_F(JSONWebKeyTest, ExtractValidJWKKeys) {
@@ -397,26 +401,26 @@ TEST_F(JSONWebKeyTest, Alg) {
 TEST_F(JSONWebKeyTest, SessionType) {
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}", true,
-      MediaKeys::TEMPORARY_SESSION);
+      ContentDecryptionModule::TEMPORARY_SESSION);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"temporary\"}",
-      true, MediaKeys::TEMPORARY_SESSION);
+      true, ContentDecryptionModule::TEMPORARY_SESSION);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"persistent-license\"}",
-      true, MediaKeys::PERSISTENT_LICENSE_SESSION);
+      true, ContentDecryptionModule::PERSISTENT_LICENSE_SESSION);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"persistent-release-message\"}",
-      true, MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION);
+      true, ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"unknown\"}",
-      false, MediaKeys::TEMPORARY_SESSION);
+      false, ContentDecryptionModule::TEMPORARY_SESSION);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":3}",
-      false, MediaKeys::TEMPORARY_SESSION);
+      false, ContentDecryptionModule::TEMPORARY_SESSION);
 }
 
 TEST_F(JSONWebKeyTest, CreateLicense) {
@@ -425,22 +429,22 @@ TEST_F(JSONWebKeyTest, CreateLicense) {
   const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                            0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
 
-  CreateLicenseAndExpect(data1,
-                         arraysize(data1),
-                         MediaKeys::TEMPORARY_SESSION,
+  CreateLicenseAndExpect(data1, arraysize(data1),
+                         ContentDecryptionModule::TEMPORARY_SESSION,
                          "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}");
   CreateLicenseAndExpect(
-      data1, arraysize(data1), MediaKeys::PERSISTENT_LICENSE_SESSION,
+      data1, arraysize(data1),
+      ContentDecryptionModule::PERSISTENT_LICENSE_SESSION,
       "{\"kids\":[\"AQI\"],\"type\":\"persistent-license\"}");
   CreateLicenseAndExpect(
-      data1, arraysize(data1), MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION,
+      data1, arraysize(data1),
+      ContentDecryptionModule::PERSISTENT_RELEASE_MESSAGE_SESSION,
       "{\"kids\":[\"AQI\"],\"type\":\"persistent-release-message\"}");
-  CreateLicenseAndExpect(data2,
-                         arraysize(data2),
-                         MediaKeys::TEMPORARY_SESSION,
+  CreateLicenseAndExpect(data2, arraysize(data2),
+                         ContentDecryptionModule::TEMPORARY_SESSION,
                          "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}");
   CreateLicenseAndExpect(data3, arraysize(data3),
-                         MediaKeys::PERSISTENT_LICENSE_SESSION,
+                         ContentDecryptionModule::PERSISTENT_LICENSE_SESSION,
                          "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":"
                          "\"persistent-license\"}");
 }
@@ -506,7 +510,8 @@ TEST_F(JSONWebKeyTest, Base64UrlEncoding) {
   EXPECT_EQ(encoded_text.find('-'), std::string::npos);
   EXPECT_EQ(encoded_text.find('_'), std::string::npos);
 
-  CreateLicenseAndExpect(data1, arraysize(data1), MediaKeys::TEMPORARY_SESSION,
+  CreateLicenseAndExpect(data1, arraysize(data1),
+                         ContentDecryptionModule::TEMPORARY_SESSION,
                          "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}");
 
   ExtractKeyFromLicenseAndExpect(
@@ -525,7 +530,8 @@ TEST_F(JSONWebKeyTest, MultipleKeys) {
   key_ids.push_back(std::vector<uint8_t>(data1, data1 + arraysize(data1)));
   key_ids.push_back(std::vector<uint8_t>(data2, data2 + arraysize(data2)));
   key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3)));
-  CreateLicenseRequest(key_ids, MediaKeys::TEMPORARY_SESSION, &result);
+  CreateLicenseRequest(key_ids, ContentDecryptionModule::TEMPORARY_SESSION,
+                       &result);
   std::string s(result.begin(), result.end());
   EXPECT_EQ(
       "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":"