Switch to standard integer types in media/.

media/cdm/cdm_adapter_unittest.cc

 // Copyright 2015 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 "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_key_information.h"
@@ skipping 11 matching lines @@
 
 // TODO(jrummell): These tests are a subset of those in aes_decryptor_unittest.
 // Refactor aes_decryptor_unittest.cc to handle AesDecryptor directly and
 // via CdmAdapter once CdmAdapter supports decrypting functionality. There
 // will also be tests that only CdmAdapter supports, like file IO, which
 // will need to be handled separately.
 
 namespace media {
 
 // Random key ID used to create a session.
-const uint8 kKeyId[] = {
+const uint8_t kKeyId[] = {
     // base64 equivalent is AQIDBAUGBwgJCgsMDQ4PEA
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
     0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 };
 
 const char kKeyIdAsJWK[] = "{\"kids\": [\"AQIDBAUGBwgJCgsMDQ4PEA\"]}";
 
-const uint8 kKeyIdAsPssh[] = {
+const uint8_t kKeyIdAsPssh[] = {
     0x00, 0x00, 0x00, 0x00, 'p',  's',  's',  'h',   // size = 0
     0x01,                                            // version = 1
     0x00, 0x00, 0x00,                                // flags
     0x10, 0x77, 0xEF, 0xEC, 0xC0, 0xB2, 0x4D, 0x02,  // Common SystemID
     0xAC, 0xE3, 0x3C, 0x1E, 0x52, 0xE2, 0xFB, 0x4B,
     0x00, 0x00, 0x00, 0x01,                          // key count
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,  // key
     0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
     0x00, 0x00, 0x00, 0x00,  // datasize
 };
@@ skipping 39 matching lines @@
                    base::Unretained(this)),
         base::Bind(&CdmAdapterTest::OnCdmCreated, base::Unretained(this),
                    expected_result));
     RunUntilIdle();
   }
 
   // Creates a new session using |key_id|. |session_id_| will be set
   // when the promise is resolved. |expected_result| tests that
   // CreateSessionAndGenerateRequest() succeeds or generates an error.
   void CreateSessionAndExpect(EmeInitDataType data_type,
-                              const std::vector<uint8>& key_id,
+                              const std::vector<uint8_t>& key_id,
                               ExpectedResult expected_result) {
     DCHECK(!key_id.empty());
 
     if (expected_result == SUCCESS) {
       EXPECT_CALL(*this,
                   OnSessionMessage(IsNotEmpty(), _, _, GURL::EmptyGURL()));
     }
 
     adapter_->CreateSessionAndGenerateRequest(
         MediaKeys::TEMPORARY_SESSION, data_type, key_id,
@@ skipping 23 matching lines @@
     DCHECK(!key.empty());
 
     if (expected_result == SUCCESS) {
       EXPECT_CALL(*this,
                   OnSessionKeysChangeCalled(session_id, new_key_expected));
     } else {
       EXPECT_CALL(*this, OnSessionKeysChangeCalled(_, _)).Times(0);
     }
 
     adapter_->UpdateSession(session_id,
-                            std::vector<uint8>(key.begin(), key.end()),
+                            std::vector<uint8_t>(key.begin(), key.end()),
                             CreatePromise(expected_result));
     RunUntilIdle();
   }
 
   base::FilePath ExternalClearKeyLibrary() { return helper_.LibraryPath(); }
 
   std::string SessionId() { return session_id_; }
 
  private:
   void OnCdmCreated(ExpectedResult expected_result,
@@ skipping 41 matching lines @@
     return promise.Pass();
   }
 
   void RunUntilIdle() { message_loop_.RunUntilIdle(); }
 
   // Methods used for promise resolved/rejected.
   MOCK_METHOD0(OnResolve, void());
   MOCK_METHOD1(OnResolveWithSession, void(const std::string& session_id));
   MOCK_METHOD3(OnReject,
                void(MediaKeys::Exception exception_code,
-                    uint32 system_code,
+                    uint32_t system_code,
                     const std::string& error_message));
 
   // Methods used for the events possibly generated by CdmAdapater.
   MOCK_METHOD4(OnSessionMessage,
                void(const std::string& session_id,
                     MediaKeys::MessageType message_type,
                     const std::vector<uint8_t>& message,
                     const GURL& legacy_destination_url));
   MOCK_METHOD1(OnSessionClosed, void(const std::string& session_id));
   MOCK_METHOD4(OnLegacySessionError,
@@ skipping 33 matching lines @@
 }
 
 TEST_F(CdmAdapterTest, BadLibraryPath) {
   InitializeAndExpect(base::FilePath(FILE_PATH_LITERAL("no_library_here")),
                       FAILURE);
 }
 
 TEST_F(CdmAdapterTest, CreateWebmSession) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
-  std::vector<uint8> key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::WEBM, key_id, SUCCESS);
 }
 
 TEST_F(CdmAdapterTest, CreateKeyIdsSession) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
   // Don't include the trailing /0 from the string in the data passed in.
-  std::vector<uint8> key_id(kKeyIdAsJWK,
-                            kKeyIdAsJWK + arraysize(kKeyIdAsJWK) - 1);
+  std::vector<uint8_t> key_id(kKeyIdAsJWK,
+                              kKeyIdAsJWK + arraysize(kKeyIdAsJWK) - 1);
   CreateSessionAndExpect(EmeInitDataType::KEYIDS, key_id, SUCCESS);
 }
 
 TEST_F(CdmAdapterTest, CreateCencSession) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
-  std::vector<uint8> key_id(kKeyIdAsPssh,
-                            kKeyIdAsPssh + arraysize(kKeyIdAsPssh));
+  std::vector<uint8_t> key_id(kKeyIdAsPssh,
+                              kKeyIdAsPssh + arraysize(kKeyIdAsPssh));
 #if defined(USE_PROPRIETARY_CODECS)
   CreateSessionAndExpect(EmeInitDataType::CENC, key_id, SUCCESS);
 #else
   CreateSessionAndExpect(EmeInitDataType::CENC, key_id, FAILURE);
 #endif
 }
 
 TEST_F(CdmAdapterTest, CreateSessionWithBadData) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
   // Use |kKeyId| but specify KEYIDS format.
-  std::vector<uint8> key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::KEYIDS, key_id, FAILURE);
 }
 
 TEST_F(CdmAdapterTest, LoadSession) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
   // LoadSession() is not supported by AesDecryptor.
-  std::vector<uint8> key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::KEYIDS, key_id, FAILURE);
 }
 
 TEST_F(CdmAdapterTest, UpdateSession) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
-  std::vector<uint8> key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::WEBM, key_id, SUCCESS);
 
   UpdateSessionAndExpect(SessionId(), kKeyAsJWK, SUCCESS, true);
 }
 
 TEST_F(CdmAdapterTest, UpdateSessionWithBadData) {
   InitializeAndExpect(ExternalClearKeyLibrary(), SUCCESS);
 
-  std::vector<uint8> key_id(kKeyId, kKeyId + arraysize(kKeyId));
+  std::vector<uint8_t> key_id(kKeyId, kKeyId + arraysize(kKeyId));
   CreateSessionAndExpect(EmeInitDataType::WEBM, key_id, SUCCESS);
 
   UpdateSessionAndExpect(SessionId(), "random data", FAILURE, true);
 }
 
 }  // namespace media