Switch to standard integer types in media/.

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 "base/base64.h"
 #include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 22 matching lines @@
     KeyIdAndKeyPairs keys;
     MediaKeys::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* key_id,
+  void CreateLicenseAndExpect(const uint8_t* key_id,
                               int key_id_length,
                               MediaKeys::SessionType session_type,
                               const std::string& expected_result) {
-    std::vector<uint8> result;
+    std::vector<uint8_t> result;
     KeyIdList key_ids;
-    key_ids.push_back(std::vector<uint8>(key_id, key_id + key_id_length));
+    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,
                                       bool expected_result,
-                                      const uint8* expected_key,
+                                      const uint8_t* expected_key,
                                       int expected_key_length) {
-    std::vector<uint8> license_vector(license.begin(), license.end());
-    std::vector<uint8> key;
+    std::vector<uint8_t> license_vector(license.begin(), license.end());
+    std::vector<uint8_t> key;
     EXPECT_EQ(expected_result,
               ExtractFirstKeyIdFromLicenseRequest(license_vector, &key));
     if (expected_result)
       VerifyKeyId(key, expected_key, expected_key_length);
   }
 
-  void VerifyKeyId(std::vector<uint8> key,
-                   const uint8* expected_key,
+  void VerifyKeyId(std::vector<uint8_t> key,
+                   const uint8_t* expected_key,
                    int expected_key_length) {
-    std::vector<uint8> key_result(expected_key,
-                                  expected_key + expected_key_length);
+    std::vector<uint8_t> key_result(expected_key,
+                                    expected_key + expected_key_length);
     EXPECT_EQ(key_result, key);
   }
 
-  KeyIdAndKeyPair MakeKeyIdAndKeyPair(const uint8* key,
+  KeyIdAndKeyPair MakeKeyIdAndKeyPair(const uint8_t* key,
                                       int key_length,
-                                      const uint8* key_id,
+                                      const uint8_t* key_id,
                                       int key_id_length) {
     return std::make_pair(std::string(key_id, key_id + key_id_length),
                           std::string(key, key + key_length));
   }
 };
 
 TEST_F(JSONWebKeyTest, GenerateJWKSet) {
-  const uint8 data1[] = { 0x01, 0x02 };
-  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
-  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+  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};
 
   EXPECT_EQ("{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}",
             GenerateJWKSet(data1, arraysize(data1), data1, arraysize(data1)));
   EXPECT_EQ(
       "{\"keys\":[{\"k\":\"AQIDBA\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"}]}",
       GenerateJWKSet(data2, arraysize(data2), data2, arraysize(data2)));
   EXPECT_EQ("{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQIDBA\",\"kty\":\"oct\"}]}",
             GenerateJWKSet(data1, arraysize(data1), data2, arraysize(data2)));
   EXPECT_EQ("{\"keys\":[{\"k\":\"AQIDBA\",\"kid\":\"AQI\",\"kty\":\"oct\"}]}",
             GenerateJWKSet(data2, arraysize(data2), data1, arraysize(data1)));
@@ skipping 310 matching lines @@
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":"
       "\"unknown\"}",
       false, MediaKeys::TEMPORARY_SESSION);
   ExtractSessionTypeAndExpect(
       "{\"keys\":[{\"k\":\"AQI\",\"kid\":\"AQI\",\"kty\":\"oct\"}],\"type\":3}",
       false, MediaKeys::TEMPORARY_SESSION);
 }
 
 TEST_F(JSONWebKeyTest, CreateLicense) {
-  const uint8 data1[] = { 0x01, 0x02 };
-  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
-  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+  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,
                          "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}");
   CreateLicenseAndExpect(
       data1, arraysize(data1), MediaKeys::PERSISTENT_LICENSE_SESSION,
       "{\"kids\":[\"AQI\"],\"type\":\"persistent-license\"}");
   CreateLicenseAndExpect(
       data1, arraysize(data1), MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION,
       "{\"kids\":[\"AQI\"],\"type\":\"persistent-release-message\"}");
   CreateLicenseAndExpect(data2,
                          arraysize(data2),
                          MediaKeys::TEMPORARY_SESSION,
                          "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}");
   CreateLicenseAndExpect(data3, arraysize(data3),
                          MediaKeys::PERSISTENT_LICENSE_SESSION,
                          "{\"kids\":[\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":"
                          "\"persistent-license\"}");
 }
 
 TEST_F(JSONWebKeyTest, ExtractLicense) {
-  const uint8 data1[] = { 0x01, 0x02 };
-  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
-  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+  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};
 
   ExtractKeyFromLicenseAndExpect(
       "{\"kids\":[\"AQI\"],\"type\":\"temporary\"}",
       true,
       data1,
       arraysize(data1));
   ExtractKeyFromLicenseAndExpect(
       "{\"kids\":[\"AQIDBA\"],\"type\":\"temporary\"}",
       true,
       data2,
@@ skipping 19 matching lines @@
   ExtractKeyFromLicenseAndExpect("{\"kids\":[]}", false, NULL, 0);
 
   // Correct tag, but list doesn't contain a string.
   ExtractKeyFromLicenseAndExpect("{\"kids\":[[\"AQI\"]]}", false, NULL, 0);
 
   // Correct tag, but invalid base64 encoding.
   ExtractKeyFromLicenseAndExpect("{\"kids\":[\"!@#$%^&*()\"]}", false, NULL, 0);
 }
 
 TEST_F(JSONWebKeyTest, Base64UrlEncoding) {
-  const uint8 data1[] = { 0xfb, 0xfd, 0xfb, 0xfd, 0xfb, 0xfd, 0xfb };
+  const uint8_t data1[] = {0xfb, 0xfd, 0xfb, 0xfd, 0xfb, 0xfd, 0xfb};
 
   // Verify that |data1| contains invalid base64url characters '+' and '/'
   // and is padded with = when converted to base64.
   std::string encoded_text;
   base::Base64Encode(
       std::string(reinterpret_cast<const char*>(&data1[0]), arraysize(data1)),
       &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,
                          "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}");
 
   ExtractKeyFromLicenseAndExpect(
       "{\"kids\":[\"-_37_fv9-w\"],\"type\":\"temporary\"}", true, data1,
       arraysize(data1));
 }
 
 TEST_F(JSONWebKeyTest, MultipleKeys) {
-  const uint8 data1[] = { 0x01, 0x02 };
-  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
-  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+  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> result;
+  std::vector<uint8_t> result;
   KeyIdList key_ids;
-  key_ids.push_back(std::vector<uint8>(data1, data1 + arraysize(data1)));
-  key_ids.push_back(std::vector<uint8>(data2, data2 + arraysize(data2)));
-  key_ids.push_back(std::vector<uint8>(data3, data3 + arraysize(data3)));
+  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);
   std::string s(result.begin(), result.end());
   EXPECT_EQ(
       "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"],\"type\":"
       "\"temporary\"}",
       s);
 }
 
 TEST_F(JSONWebKeyTest, ExtractKeyIds) {
-  const uint8 data1[] = { 0x01, 0x02 };
-  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
-  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+  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};
 
   KeyIdList key_ids;
   std::string error_message;
 
   EXPECT_TRUE(ExtractKeyIdsFromKeyIdsInitData("{\"kids\":[\"AQI\"]}", &key_ids,
                                               &error_message));
   EXPECT_EQ(1u, key_ids.size());
   EXPECT_EQ(0u, error_message.length());
   VerifyKeyId(key_ids[0], data1, arraysize(data1));
 
@@ skipping 54 matching lines @@
   EXPECT_EQ(error_message,
             "'kids'[0] is not valid base64url encoded. Value: AQI+");
   EXPECT_FALSE(ExtractKeyIdsFromKeyIdsInitData("{\"kids\":[\"AQI\",\"AQI/\"]}",
                                                &key_ids, &error_message));
   EXPECT_EQ(3u, key_ids.size());  // |key_ids| should be unchanged.
   EXPECT_EQ(error_message,
             "'kids'[1] is not valid base64url encoded. Value: AQI/");
 }
 
 TEST_F(JSONWebKeyTest, CreateInitData) {
-  const uint8 data1[] = { 0x01, 0x02 };
-  const uint8 data2[] = { 0x01, 0x02, 0x03, 0x04 };
-  const uint8 data3[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-                          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10 };
+  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};
 
   KeyIdList key_ids;
   std::string error_message;
 
-  key_ids.push_back(std::vector<uint8>(data1, data1 + arraysize(data1)));
-  std::vector<uint8> init_data1;
+  key_ids.push_back(std::vector<uint8_t>(data1, data1 + arraysize(data1)));
+  std::vector<uint8_t> init_data1;
   CreateKeyIdsInitData(key_ids, &init_data1);
   std::string result1(init_data1.begin(), init_data1.end());
   EXPECT_EQ(result1, "{\"kids\":[\"AQI\"]}");
 
-  key_ids.push_back(std::vector<uint8>(data2, data2 + arraysize(data2)));
-  std::vector<uint8> init_data2;
+  key_ids.push_back(std::vector<uint8_t>(data2, data2 + arraysize(data2)));
+  std::vector<uint8_t> init_data2;
   CreateKeyIdsInitData(key_ids, &init_data2);
   std::string result2(init_data2.begin(), init_data2.end());
   EXPECT_EQ(result2, "{\"kids\":[\"AQI\",\"AQIDBA\"]}");
 
-  key_ids.push_back(std::vector<uint8>(data3, data3 + arraysize(data3)));
-  std::vector<uint8> init_data3;
+  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