media: Rename MediaKeys to ContentDecryptionModule

media/cdm/json_web_key_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 "media/cdm/json_web_key.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #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 {
 
 class JSONWebKeyTest : public testing::Test {
  public:
   JSONWebKeyTest() {}
 
  protected:
   void ExtractJWKKeysAndExpect(const std::string& jwk,
                                bool expected_result,
                                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) {
       // Only check if successful.
       EXPECT_EQ(expected_type, session_type);
     }
   }
 
   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;
     key_ids.push_back(std::vector<uint8_t>(key_id, key_id + key_id_length));
     CreateLicenseRequest(key_ids, session_type, &result);
     std::string s(result.begin(), result.end());
     EXPECT_EQ(expected_result, s);
   }
 
   void ExtractKeyFromLicenseAndExpect(const std::string& license,
@@ skipping 44 matching lines @@
       "{\"keys\":[{\"k\":\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kid\":"
       "\"AQIDBAUGBwgJCgsMDQ4PEA\",\"kty\":\"oct\"}]}",
       GenerateJWKSet(data3, arraysize(data3), data3, arraysize(data3)));
 
   KeyIdAndKeyPairs keys;
   keys.push_back(
       MakeKeyIdAndKeyPair(data1, arraysize(data1), data1, arraysize(data1)));
   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(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"},{\"k\":"
       "\"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) {
   // Try an empty 'keys' dictionary.
   ExtractJWKKeysAndExpect("{ \"keys\": [] }", true, 0);
 
   // Try a key list with one entry.
   const std::string kJwksOneEntry =
       "{"
       "  \"keys\": ["
@@ skipping 250 matching lines @@
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   ExtractJWKKeysAndExpect(kJwksWithWrongAlg, true, 1);
 }
 
 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) {
   const uint8_t data1[] = {0x01, 0x02};
   const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04};
   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\"}");
 }
 
 TEST_F(JSONWebKeyTest, ExtractLicense) {
   const uint8_t data1[] = {0x01, 0x02};
   const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04};
   const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                            0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
 
@@ skipping 45 matching lines @@
       &encoded_text);
   EXPECT_EQ(encoded_text, "+/37/fv9+w==");
   EXPECT_NE(encoded_text.find('+'), std::string::npos);
   EXPECT_NE(encoded_text.find('/'), std::string::npos);
   EXPECT_NE(encoded_text.find('='), std::string::npos);
 
   // base64url characters '-' and '_' not in base64 encoding.
   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(
       "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}", true, data1,
       arraysize(data1));
 }
 
 TEST_F(JSONWebKeyTest, MultipleKeys) {
   const uint8_t data1[] = {0x01, 0x02};
   const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04};
   const uint8_t data3[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
                            0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
 
   std::vector<uint8_t> result;
   KeyIdList key_ids;
   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\":"
       "\"temporary\"}",
       s);
 }
 
 TEST_F(JSONWebKeyTest, ExtractKeyIds) {
   const uint8_t data1[] = {0x01, 0x02};
   const uint8_t data2[] = {0x01, 0x02, 0x03, 0x04};
@@ skipping 96 matching lines @@
   key_ids.push_back(std::vector<uint8_t>(data3, data3 + arraysize(data3)));
   std::vector<uint8_t> init_data3;
   CreateKeyIdsInitData(key_ids, &init_data3);
   std::string result3(init_data3.begin(), init_data3.end());
   EXPECT_EQ(result3,
             "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"]}");
 }
 
 }  // namespace media