Switch to standard integer types in media/.

media/cdm/aes_decryptor_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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/json/json_reader.h"
 #include "base/values.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/decryptor.h"
@@ skipping 18 matching lines @@
 MATCHER(IsEmpty, "") { return arg.empty(); }
 MATCHER(IsNotEmpty, "") { return !arg.empty(); }
 MATCHER(IsJSONDictionary, "") {
   std::string result(arg.begin(), arg.end());
   scoped_ptr<base::Value> root(base::JSONReader().ReadToValue(result));
   return (root.get() && root->GetType() == base::Value::TYPE_DICTIONARY);
 }
 
 namespace media {
 
-const uint8 kOriginalData[] = "Original subsample data.";
+const uint8_t kOriginalData[] = "Original subsample data.";
 const int kOriginalDataSize = 24;
 
 // In the examples below, 'k'(key) has to be 16 bytes, and will always require
 // 2 bytes of padding. 'kid'(keyid) is variable length, and may require 0, 1,
 // or 2 bytes of padding.
 
-const uint8 kKeyId[] = {
+const uint8_t kKeyId[] = {
     // base64 equivalent is AAECAw
-    0x00, 0x01, 0x02, 0x03
-};
+    0x00, 0x01, 0x02, 0x03};
 
 // Key is 0x0405060708090a0b0c0d0e0f10111213,
 // base64 equivalent is BAUGBwgJCgsMDQ4PEBESEw.
 const char kKeyAsJWK[] =
     "{"
     "  \"keys\": ["
     "    {"
     "      \"kty\": \"oct\","
     "      \"alg\": \"A128KW\","
     "      \"kid\": \"AAECAw\","
@@ skipping 33 matching lines @@
     "  \"keys\": ["
     "    {"
     "      \"kty\": \"oct\","
     "      \"alg\": \"A128KW\","
     "      \"kid\": \"AAECAw\","
     "      \"k\": \"AAECAw\""
     "    }"
     "  ]"
     "}";
 
-const uint8 kIv[] = {
-  0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
+const uint8_t kIv[] = {0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
 // kOriginalData encrypted with kKey and kIv but without any subsamples (or
 // equivalently using kSubsampleEntriesCypherOnly).
-const uint8 kEncryptedData[] = {
-  0x2f, 0x03, 0x09, 0xef, 0x71, 0xaf, 0x31, 0x16,
-  0xfa, 0x9d, 0x18, 0x43, 0x1e, 0x96, 0x71, 0xb5,
-  0xbf, 0xf5, 0x30, 0x53, 0x9a, 0x20, 0xdf, 0x95
-};
+const uint8_t kEncryptedData[] = {
+    0x2f, 0x03, 0x09, 0xef, 0x71, 0xaf, 0x31, 0x16, 0xfa, 0x9d, 0x18, 0x43,
+    0x1e, 0x96, 0x71, 0xb5, 0xbf, 0xf5, 0x30, 0x53, 0x9a, 0x20, 0xdf, 0x95};
 
 // kOriginalData encrypted with kSubsampleKey and kSubsampleIv using
 // kSubsampleEntriesNormal.
-const uint8 kSubsampleEncryptedData[] = {
-  0x4f, 0x72, 0x09, 0x16, 0x09, 0xe6, 0x79, 0xad,
-  0x70, 0x73, 0x75, 0x62, 0x09, 0xbb, 0x83, 0x1d,
-  0x4d, 0x08, 0xd7, 0x78, 0xa4, 0xa7, 0xf1, 0x2e
-};
+const uint8_t kSubsampleEncryptedData[] = {
+    0x4f, 0x72, 0x09, 0x16, 0x09, 0xe6, 0x79, 0xad, 0x70, 0x73, 0x75, 0x62,
+    0x09, 0xbb, 0x83, 0x1d, 0x4d, 0x08, 0xd7, 0x78, 0xa4, 0xa7, 0xf1, 0x2e};
 
-const uint8 kOriginalData2[] = "Changed Original data.";
+const uint8_t kOriginalData2[] = "Changed Original data.";
 
-const uint8 kIv2[] = {
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
+const uint8_t kIv2[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-const uint8 kKeyId2[] = {
+const uint8_t kKeyId2[] = {
     // base64 equivalent is AAECAwQFBgcICQoLDA0ODxAREhM=
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
-    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
-    0x10, 0x11, 0x12, 0x13
-};
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+    0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13};
 
 const char kKey2AsJWK[] =
     "{"
     "  \"keys\": ["
     "    {"
     "      \"kty\": \"oct\","
     "      \"alg\": \"A128KW\","
     "      \"kid\": \"AAECAwQFBgcICQoLDA0ODxAREhM\","
     "      \"k\": \"FBUWFxgZGhscHR4fICEiIw\""
     "    }"
     "  ]"
     "}";
 
 // 'k' in bytes is x14x15x16x17x18x19x1ax1bx1cx1dx1ex1fx20x21x22x23
 
-const uint8 kEncryptedData2[] = {
-  0x57, 0x66, 0xf4, 0x12, 0x1a, 0xed, 0xb5, 0x79,
-  0x1c, 0x8e, 0x25, 0xd7, 0x17, 0xe7, 0x5e, 0x16,
-  0xe3, 0x40, 0x08, 0x27, 0x11, 0xe9
-};
+const uint8_t kEncryptedData2[] = {
+    0x57, 0x66, 0xf4, 0x12, 0x1a, 0xed, 0xb5, 0x79, 0x1c, 0x8e, 0x25,
+    0xd7, 0x17, 0xe7, 0x5e, 0x16, 0xe3, 0x40, 0x08, 0x27, 0x11, 0xe9};
 
 // Subsample entries for testing. The sum of |cypher_bytes| and |clear_bytes| of
 // all entries must be equal to kOriginalDataSize to make the subsample entries
 // valid.
 
 const SubsampleEntry kSubsampleEntriesNormal[] = {
   { 2, 7 },
   { 3, 11 },
   { 1, 0 }
 };
@@ skipping 16 matching lines @@
   { 9, 0 }
 };
 
 const SubsampleEntry kSubsampleEntriesCypherOnly[] = {
   { 0, 6 },
   { 0, 8 },
   { 0, 10 }
 };
 
 static scoped_refptr<DecoderBuffer> CreateEncryptedBuffer(
-    const std::vector<uint8>& data,
-    const std::vector<uint8>& key_id,
-    const std::vector<uint8>& iv,
+    const std::vector<uint8_t>& data,
+    const std::vector<uint8_t>& key_id,
+    const std::vector<uint8_t>& iv,
     const std::vector<SubsampleEntry>& subsample_entries) {
   DCHECK(!data.empty());
   scoped_refptr<DecoderBuffer> encrypted_buffer(new DecoderBuffer(data.size()));
   memcpy(encrypted_buffer->writable_data(), &data[0], data.size());
   CHECK(encrypted_buffer.get());
   std::string key_id_string(
       reinterpret_cast<const char*>(key_id.empty() ? NULL : &key_id[0]),
       key_id.size());
   std::string iv_string(
       reinterpret_cast<const char*>(iv.empty() ? NULL : &iv[0]), iv.size());
@@ skipping 77 matching lines @@
     EXPECT_GT(session_id.length(), 0ul);
     session_id_ = session_id;
   }
 
   void OnResolve(ExpectedResult expected_result) {
     EXPECT_EQ(expected_result, RESOLVED) << "Unexpectedly resolved.";
   }
 
   void OnReject(ExpectedResult expected_result,
                 MediaKeys::Exception exception_code,
-                uint32 system_code,
+                uint32_t system_code,
                 const std::string& error_message) {
     EXPECT_EQ(expected_result, REJECTED)
         << "Unexpectedly rejected with message: " << error_message;
   }
 
   scoped_ptr<SimpleCdmPromise> CreatePromise(ExpectedResult expected_result) {
     scoped_ptr<SimpleCdmPromise> promise(
         new CdmCallbackPromise<>(base::Bind(&AesDecryptorTest::OnResolve,
                                             base::Unretained(this),
                                             expected_result),
@@ skipping 10 matching lines @@
             base::Bind(&AesDecryptorTest::OnResolveWithSession,
                        base::Unretained(this),
                        expected_result),
             base::Bind(&AesDecryptorTest::OnReject,
                        base::Unretained(this),
                        expected_result)));
     return promise.Pass();
   }
 
   // Creates a new session using |key_id|. Returns the session ID.
-  std::string CreateSession(const std::vector<uint8>& key_id) {
+  std::string CreateSession(const std::vector<uint8_t>& key_id) {
     DCHECK(!key_id.empty());
     EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                         GURL::EmptyGURL()));
     cdm_->CreateSessionAndGenerateRequest(MediaKeys::TEMPORARY_SESSION,
                                           EmeInitDataType::WEBM, key_id,
                                           CreateSessionPromise(RESOLVED));
     // This expects the promise to be called synchronously, which is the case
     // for AesDecryptor.
     return session_id_;
   }
@@ skipping 37 matching lines @@
                               bool new_key_expected) {
     DCHECK(!key.empty());
 
     if (expected_result == RESOLVED) {
       EXPECT_CALL(*this,
                   OnSessionKeysChangeCalled(session_id, new_key_expected));
     } else {
       EXPECT_CALL(*this, OnSessionKeysChangeCalled(_, _)).Times(0);
     }
 
-    cdm_->UpdateSession(session_id, std::vector<uint8>(key.begin(), key.end()),
+    cdm_->UpdateSession(session_id,
+                        std::vector<uint8_t>(key.begin(), key.end()),
                         CreatePromise(expected_result));
   }
 
-  bool KeysInfoContains(std::vector<uint8> expected) {
+  bool KeysInfoContains(std::vector<uint8_t> expected) {
     for (const auto& key_id : keys_info_) {
       if (key_id->key_id == expected)
         return true;
     }
     return false;
   }
 
   MOCK_METHOD2(BufferDecrypted, void(Decryptor::Status,
                                      const scoped_refptr<DecoderBuffer>&));
 
   enum DecryptExpectation {
     SUCCESS,
     DATA_MISMATCH,
     DATA_AND_SIZE_MISMATCH,
     DECRYPT_ERROR,
     NO_KEY
   };
 
   void DecryptAndExpect(const scoped_refptr<DecoderBuffer>& encrypted,
-                        const std::vector<uint8>& plain_text,
+                        const std::vector<uint8_t>& plain_text,
                         DecryptExpectation result) {
     scoped_refptr<DecoderBuffer> decrypted;
 
     switch (result) {
       case SUCCESS:
       case DATA_MISMATCH:
       case DATA_AND_SIZE_MISMATCH:
         EXPECT_CALL(*this, BufferDecrypted(Decryptor::kSuccess, NotNull()))
             .WillOnce(SaveArg<1>(&decrypted));
         break;
       case DECRYPT_ERROR:
         EXPECT_CALL(*this, BufferDecrypted(Decryptor::kError, IsNull()))
             .WillOnce(SaveArg<1>(&decrypted));
         break;
       case NO_KEY:
         EXPECT_CALL(*this, BufferDecrypted(Decryptor::kNoKey, IsNull()))
             .WillOnce(SaveArg<1>(&decrypted));
         break;
     }
 
     if (GetParam() == "CdmAdapter") {
       ANNOTATE_SCOPED_MEMORY_LEAK;  // http://crbug.com/569736
       decryptor_->Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     } else {
       decryptor_->Decrypt(Decryptor::kVideo, encrypted, decrypt_cb_);
     }
 
-    std::vector<uint8> decrypted_text;
+    std::vector<uint8_t> decrypted_text;
     if (decrypted.get() && decrypted->data_size()) {
       decrypted_text.assign(
         decrypted->data(), decrypted->data() + decrypted->data_size());
     }
 
     switch (result) {
       case SUCCESS:
         EXPECT_EQ(plain_text, decrypted_text);
         break;
       case DATA_MISMATCH:
         EXPECT_EQ(plain_text.size(), decrypted_text.size());
         EXPECT_NE(plain_text, decrypted_text);
         break;
       case DATA_AND_SIZE_MISMATCH:
         EXPECT_NE(plain_text.size(), decrypted_text.size());
         break;
       case DECRYPT_ERROR:
       case NO_KEY:
         EXPECT_TRUE(decrypted_text.empty());
         break;
     }
   }
 
   MOCK_METHOD4(OnSessionMessage,
                void(const std::string& session_id,
                     MediaKeys::MessageType message_type,
-                    const std::vector<uint8>& message,
+                    const std::vector<uint8_t>& message,
                     const GURL& legacy_destination_url));
   MOCK_METHOD1(OnSessionClosed, void(const std::string& session_id));
   MOCK_METHOD4(OnLegacySessionError,
                void(const std::string& session_id,
                     MediaKeys::Exception exception,
                     uint32_t system_code,
                     const std::string& error_message));
   MOCK_METHOD2(OnSessionExpirationUpdate,
                void(const std::string& session_id,
                     const base::Time& new_expiry_time));
 
   scoped_refptr<MediaKeys> cdm_;
   Decryptor* decryptor_;
   Decryptor::DecryptCB decrypt_cb_;
   std::string session_id_;
   CdmKeysInfo keys_info_;
 
   // Helper class to load/unload External Clear Key Library, if necessary.
   scoped_ptr<ExternalClearKeyTestHelper> helper_;
 
   base::MessageLoop message_loop_;
 
   // Constants for testing.
-  const std::vector<uint8> original_data_;
-  const std::vector<uint8> encrypted_data_;
-  const std::vector<uint8> subsample_encrypted_data_;
-  const std::vector<uint8> key_id_;
-  const std::vector<uint8> iv_;
+  const std::vector<uint8_t> original_data_;
+  const std::vector<uint8_t> encrypted_data_;
+  const std::vector<uint8_t> subsample_encrypted_data_;
+  const std::vector<uint8_t> key_id_;
+  const std::vector<uint8_t> iv_;
   const std::vector<SubsampleEntry> normal_subsample_entries_;
   const std::vector<SubsampleEntry> no_subsample_entries_;
 };
 
 TEST_P(AesDecryptorTest, CreateSessionWithNullInitData) {
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   cdm_->CreateSessionAndGenerateRequest(
-      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
-      CreateSessionPromise(RESOLVED));
+      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      std::vector<uint8_t>(), CreateSessionPromise(RESOLVED));
 }
 
 TEST_P(AesDecryptorTest, MultipleCreateSession) {
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   cdm_->CreateSessionAndGenerateRequest(
-      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
-      CreateSessionPromise(RESOLVED));
+      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      std::vector<uint8_t>(), CreateSessionPromise(RESOLVED));
 
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   cdm_->CreateSessionAndGenerateRequest(
-      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
-      CreateSessionPromise(RESOLVED));
+      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      std::vector<uint8_t>(), CreateSessionPromise(RESOLVED));
 
   EXPECT_CALL(*this,
               OnSessionMessage(IsNotEmpty(), _, IsEmpty(), GURL::EmptyGURL()));
   cdm_->CreateSessionAndGenerateRequest(
-      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM, std::vector<uint8>(),
-      CreateSessionPromise(RESOLVED));
+      MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
+      std::vector<uint8_t>(), CreateSessionPromise(RESOLVED));
 }
 
 TEST_P(AesDecryptorTest, CreateSessionWithCencInitData) {
-  const uint8 init_data[] = {
+  const uint8_t init_data[] = {
       0x00, 0x00, 0x00, 0x44,                          // size = 68
       0x70, 0x73, 0x73, 0x68,                          // 'pssh'
       0x01,                                            // version
       0x00, 0x00, 0x00,                                // flags
       0x10, 0x77, 0xEF, 0xEC, 0xC0, 0xB2, 0x4D, 0x02,  // SystemID
       0xAC, 0xE3, 0x3C, 0x1E, 0x52, 0xE2, 0xFB, 0x4B,
       0x00, 0x00, 0x00, 0x02,                          // key count
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,  // key1
       0x7E, 0x57, 0x1D, 0x03, 0x7E, 0x57, 0x1D, 0x03,
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,  // key2
       0x7E, 0x57, 0x1D, 0x04, 0x7E, 0x57, 0x1D, 0x04,
       0x00, 0x00, 0x00, 0x00  // datasize
   };
 
 #if defined(USE_PROPRIETARY_CODECS)
   EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                       GURL::EmptyGURL()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
-      std::vector<uint8>(init_data, init_data + arraysize(init_data)),
+      std::vector<uint8_t>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(RESOLVED));
 #else
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::CENC,
-      std::vector<uint8>(init_data, init_data + arraysize(init_data)),
+      std::vector<uint8_t>(init_data, init_data + arraysize(init_data)),
       CreateSessionPromise(REJECTED));
 #endif
 }
 
 TEST_P(AesDecryptorTest, CreateSessionWithKeyIdsInitData) {
   const char init_data[] =
       "{\"kids\":[\"AQI\",\"AQIDBA\",\"AQIDBAUGBwgJCgsMDQ4PEA\"]}";
 
   EXPECT_CALL(*this, OnSessionMessage(IsNotEmpty(), _, IsJSONDictionary(),
                                       GURL::EmptyGURL()));
   cdm_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::KEYIDS,
-      std::vector<uint8>(init_data, init_data + arraysize(init_data) - 1),
+      std::vector<uint8_t>(init_data, init_data + arraysize(init_data) - 1),
       CreateSessionPromise(RESOLVED));
 }
 
 TEST_P(AesDecryptorTest, NormalDecryption) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 }
 
 TEST_P(AesDecryptorTest, UnencryptedFrame) {
   // An empty iv string signals that the frame is unencrypted.
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
-      original_data_, key_id_, std::vector<uint8>(), no_subsample_entries_);
+      original_data_, key_id_, std::vector<uint8_t>(), no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 }
 
 TEST_P(AesDecryptorTest, WrongKey) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kWrongKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, iv_, no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 }
@@ skipping 33 matching lines @@
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 
   UpdateSessionAndExpect(session_id, kKey2AsJWK, RESOLVED, true);
 
   // The first key is still available after we added a second key.
   ASSERT_NO_FATAL_FAILURE(
       DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS));
 
   // The second key is also available.
   encrypted_buffer = CreateEncryptedBuffer(
-      std::vector<uint8>(kEncryptedData2,
-                         kEncryptedData2 + arraysize(kEncryptedData2)),
-      std::vector<uint8>(kKeyId2, kKeyId2 + arraysize(kKeyId2)),
-      std::vector<uint8>(kIv2, kIv2 + arraysize(kIv2)),
+      std::vector<uint8_t>(kEncryptedData2,
+                           kEncryptedData2 + arraysize(kEncryptedData2)),
+      std::vector<uint8_t>(kKeyId2, kKeyId2 + arraysize(kKeyId2)),
+      std::vector<uint8_t>(kIv2, kIv2 + arraysize(kIv2)),
       no_subsample_entries_);
   ASSERT_NO_FATAL_FAILURE(DecryptAndExpect(
       encrypted_buffer,
-      std::vector<uint8>(kOriginalData2,
-                         kOriginalData2 + arraysize(kOriginalData2) - 1),
+      std::vector<uint8_t>(kOriginalData2,
+                           kOriginalData2 + arraysize(kOriginalData2) - 1),
       SUCCESS));
 }
 
 TEST_P(AesDecryptorTest, CorruptedIv) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
 
-  std::vector<uint8> bad_iv = iv_;
+  std::vector<uint8_t> bad_iv = iv_;
   bad_iv[1]++;
 
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       encrypted_data_, key_id_, bad_iv, no_subsample_entries_);
 
   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 }
 
 TEST_P(AesDecryptorTest, CorruptedData) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
 
-  std::vector<uint8> bad_data = encrypted_data_;
+  std::vector<uint8_t> bad_data = encrypted_data_;
   bad_data[1]++;
 
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       bad_data, key_id_, iv_, no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 }
 
 TEST_P(AesDecryptorTest, EncryptedAsUnencryptedFailure) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
-      encrypted_data_, key_id_, std::vector<uint8>(), no_subsample_entries_);
+      encrypted_data_, key_id_, std::vector<uint8_t>(), no_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, DATA_MISMATCH);
 }
 
 TEST_P(AesDecryptorTest, SubsampleDecryption) {
   std::string session_id = CreateSession(key_id_);
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   scoped_refptr<DecoderBuffer> encrypted_buffer = CreateEncryptedBuffer(
       subsample_encrypted_data_, key_id_, iv_, normal_subsample_entries_);
   DecryptAndExpect(encrypted_buffer, original_data_, SUCCESS);
 }
@@ skipping 280 matching lines @@
       "      \"kid\": \"\","
       "      \"k\": \"BAUGBwgJCgsMDQ4PEBESEw\""
       "    }"
       "  ]"
       "}";
   UpdateSessionAndExpect(session_id, kJwksWithEmptyKeyId, REJECTED, true);
   CloseSession(session_id);
 }
 
 TEST_P(AesDecryptorTest, GetKeyIds) {
-  std::vector<uint8> key_id1(kKeyId, kKeyId + arraysize(kKeyId));
-  std::vector<uint8> key_id2(kKeyId2, kKeyId2 + arraysize(kKeyId2));
+  std::vector<uint8_t> key_id1(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id2(kKeyId2, kKeyId2 + arraysize(kKeyId2));
 
   std::string session_id = CreateSession(key_id_);
   EXPECT_FALSE(KeysInfoContains(key_id1));
   EXPECT_FALSE(KeysInfoContains(key_id2));
 
   // Add 1 key, verify it is returned.
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   EXPECT_TRUE(KeysInfoContains(key_id1));
   EXPECT_FALSE(KeysInfoContains(key_id2));
 
   // Add second key, verify both IDs returned.
   UpdateSessionAndExpect(session_id, kKey2AsJWK, RESOLVED, true);
   EXPECT_TRUE(KeysInfoContains(key_id1));
   EXPECT_TRUE(KeysInfoContains(key_id2));
 }
 
 TEST_P(AesDecryptorTest, NoKeysChangeForSameKey) {
-  std::vector<uint8> key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
 
   std::string session_id = CreateSession(key_id_);
   EXPECT_FALSE(KeysInfoContains(key_id));
 
   // Add key, verify it is returned.
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, true);
   EXPECT_TRUE(KeysInfoContains(key_id));
 
   // Add key a second time.
   UpdateSessionAndExpect(session_id, kKeyAsJWK, RESOLVED, false);
@@ skipping 12 matching lines @@
 INSTANTIATE_TEST_CASE_P(CdmAdapter,
                         AesDecryptorTest,
                         testing::Values("CdmAdapter"));
 #endif
 
 // TODO(jrummell): Once MojoCdm/MojoCdmService/MojoDecryptor/
 // MojoDecryptorService are implemented, add a third version that tests the
 // CDM via mojo.
 
 }  // namespace media