Remove kint64min.

media/cdm/ppapi/external_clear_key/clear_key_cdm.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/ppapi/external_clear_key/clear_key_cdm.h"
 
 #include <algorithm>
 #include <cstring>
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/cdm_callback_promise.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/key_systems.h"
 #include "media/cdm/json_web_key.h"
 #include "media/cdm/ppapi/cdm_file_io_test.h"
 #include "media/cdm/ppapi/external_clear_key/cdm_video_decoder.h"
 #include "url/gurl.h"
 
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
-#include "base/basictypes.h"
-const int64 kNoTimestamp = kint64min;
+const int64_t kNoTimestamp = INT64_MIN;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
 #include "base/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "media/base/media.h"
 #include "media/cdm/ppapi/external_clear_key/ffmpeg_cdm_audio_decoder.h"
 #include "media/cdm/ppapi/external_clear_key/ffmpeg_cdm_video_decoder.h"
 
@@ skipping 24 matching lines @@
     "org.chromium.externalclearkey.decryptonly";
 const char kExternalClearKeyFileIOTestKeySystem[] =
     "org.chromium.externalclearkey.fileiotest";
 const char kExternalClearKeyCrashKeySystem[] =
     "org.chromium.externalclearkey.crash";
 
 // Constants for the enumalted session that can be loaded by LoadSession().
 // These constants need to be in sync with
 // chrome/test/data/media/encrypted_media_utils.js
 const char kLoadableSessionId[] = "LoadableSession";
-const uint8 kLoadableSessionKeyId[] = "0123456789012345";
-const uint8 kLoadableSessionKey[] =
-    {0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
-     0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c};
+const uint8_t kLoadableSessionKeyId[] = "0123456789012345";
+const uint8_t kLoadableSessionKey[] = {0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14,
+                                       0xd2, 0x7b, 0x68, 0xef, 0x12, 0x2a,
+                                       0xfc, 0xe4, 0xae, 0x3c};
 
-const int64 kSecondsPerMinute = 60;
-const int64 kMsPerSecond = 1000;
-const int64 kInitialTimerDelayMs = 200;
-const int64 kMaxTimerDelayMs = 1 * kSecondsPerMinute * kMsPerSecond;
+const int64_t kSecondsPerMinute = 60;
+const int64_t kMsPerSecond = 1000;
+const int64_t kInitialTimerDelayMs = 200;
+const int64_t kMaxTimerDelayMs = 1 * kSecondsPerMinute * kMsPerSecond;
 // Renewal message header. For prefixed EME, if a key message starts with
 // |kRenewalHeader|, it's a renewal message. Otherwise, it's a key request.
 // FIXME(jrummell): Remove this once prefixed EME goes away.
 const char kRenewalHeader[] = "RENEWAL";
 // CDM file IO test result header.
 const char kFileIOTestResultHeader[] = "FILEIOTESTRESULT";
 
 // Copies |input_buffer| into a media::DecoderBuffer. If the |input_buffer| is
 // empty, an empty (end-of-stream) media::DecoderBuffer is returned.
 static scoped_refptr<media::DecoderBuffer> CopyDecoderBufferFrom(
@@ skipping 190 matching lines @@
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
 void ClearKeyCdm::Initialize(bool /* allow_distinctive_identifier */,
                              bool /* allow_persistent_state */) {
   // Implementation doesn't use distinctive identifier nor save persistent data,
   // so nothing to do with these values.
 }
 
 void ClearKeyCdm::CreateSessionAndGenerateRequest(
-    uint32 promise_id,
+    uint32_t promise_id,
     cdm::SessionType session_type,
     cdm::InitDataType init_data_type,
-    const uint8* init_data,
-    uint32 init_data_size) {
+    const uint8_t* init_data,
+    uint32_t init_data_size) {
   DVLOG(1) << __FUNCTION__;
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionCreated,
                      base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed,
                      base::Unretained(this),
                      promise_id)));
   decryptor_->CreateSessionAndGenerateRequest(
       ConvertSessionType(session_type), ConvertInitDataType(init_data_type),
       std::vector<uint8_t>(init_data, init_data + init_data_size),
       promise.Pass());
 
   if (key_system_ == kExternalClearKeyFileIOTestKeySystem)
     StartFileIOTest();
 }
 
 // Loads a emulated stored session. Currently only |kLoadableSessionId|
 // (containing a |kLoadableSessionKey| for |kLoadableSessionKeyId|) is
 // supported.
-void ClearKeyCdm::LoadSession(uint32 promise_id,
+void ClearKeyCdm::LoadSession(uint32_t promise_id,
                               cdm::SessionType session_type,
                               const char* session_id,
                               uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   DCHECK_EQ(session_type, cdm::kPersistentLicense);
 
   if (std::string(kLoadableSessionId) !=
       std::string(session_id, session_id_length)) {
     host_->OnResolveNewSessionPromise(promise_id, nullptr, 0);
     return;
   }
 
   // Only allowed to successfully load this session once.
   DCHECK(session_id_for_emulated_loadsession_.empty());
 
   scoped_ptr<media::NewSessionCdmPromise> promise(
       new media::CdmCallbackPromise<std::string>(
           base::Bind(&ClearKeyCdm::OnSessionLoaded,
                      base::Unretained(this),
                      promise_id),
           base::Bind(&ClearKeyCdm::OnPromiseFailed,
                      base::Unretained(this),
                      promise_id)));
   decryptor_->CreateSessionAndGenerateRequest(
       MediaKeys::TEMPORARY_SESSION, EmeInitDataType::WEBM,
       std::vector<uint8_t>(), promise.Pass());
 }
 
-void ClearKeyCdm::UpdateSession(uint32 promise_id,
+void ClearKeyCdm::UpdateSession(uint32_t promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length,
-                                const uint8* response,
-                                uint32 response_size) {
+                                const uint8_t* response,
+                                uint32_t response_size) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If updating the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                  promise_id),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id)));
   decryptor_->UpdateSession(
       web_session_str, std::vector<uint8_t>(response, response + response_size),
       promise.Pass());
 
   if (!renewal_timer_set_) {
     ScheduleNextRenewal();
     renewal_timer_set_ = true;
   }
 }
 
-void ClearKeyCdm::CloseSession(uint32 promise_id,
+void ClearKeyCdm::CloseSession(uint32_t promise_id,
                                const char* session_id,
                                uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // If closing the loadable session, use the actual session id generated.
   if (web_session_str == std::string(kLoadableSessionId))
     web_session_str = session_id_for_emulated_loadsession_;
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(
           &ClearKeyCdm::OnPromiseResolved, base::Unretained(this), promise_id),
       base::Bind(
           &ClearKeyCdm::OnPromiseFailed, base::Unretained(this), promise_id)));
   decryptor_->CloseSession(web_session_str, promise.Pass());
 }
 
-void ClearKeyCdm::RemoveSession(uint32 promise_id,
+void ClearKeyCdm::RemoveSession(uint32_t promise_id,
                                 const char* session_id,
                                 uint32_t session_id_length) {
   DVLOG(1) << __FUNCTION__;
   std::string web_session_str(session_id, session_id_length);
 
   // RemoveSession only allowed for the loadable session.
   if (web_session_str == std::string(kLoadableSessionId)) {
     web_session_str = session_id_for_emulated_loadsession_;
   } else {
     // TODO(jrummell): This should be a DCHECK once blink does the proper
     // checks.
     std::string message("Not supported for non-persistent sessions.");
     host_->OnRejectPromise(promise_id,
                            cdm::kInvalidAccessError,
                            0,
                            message.data(),
                            message.length());
     return;
   }
 
   scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
       base::Bind(&ClearKeyCdm::OnPromiseResolved, base::Unretained(this),
                  promise_id),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id)));
   decryptor_->RemoveSession(web_session_str, promise.Pass());
 }
 
-void ClearKeyCdm::SetServerCertificate(uint32 promise_id,
+void ClearKeyCdm::SetServerCertificate(uint32_t promise_id,
                                        const uint8_t* server_certificate_data,
                                        uint32_t server_certificate_data_size) {
   // ClearKey doesn't use a server certificate.
   host_->OnResolvePromise(promise_id);
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
   if (context == &session_id_for_emulated_loadsession_) {
     LoadLoadableSession();
     return;
@@ skipping 177 matching lines @@
   int32_t size = 0;
   int64_t timestamp = 0;
   if (!buffer->end_of_stream()) {
     data = buffer->data();
     size = buffer->data_size();
     timestamp = encrypted_buffer.timestamp;
   }
 
   return audio_decoder_->DecodeBuffer(data, size, timestamp, audio_frames);
 #elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
-  int64 timestamp_in_microseconds = kNoTimestamp;
+  int64_t timestamp_in_microseconds = kNoTimestamp;
   if (!buffer->end_of_stream()) {
     timestamp_in_microseconds = buffer->GetTimestamp().InMicroseconds();
     DCHECK(timestamp_in_microseconds != kNoTimestamp);
   }
   return GenerateFakeAudioFrames(timestamp_in_microseconds, audio_frames);
 #else
   return cdm::kSuccess;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
@@ skipping 68 matching lines @@
       base::Bind(&ClearKeyCdm::OnLoadSessionUpdated, base::Unretained(this)),
       base::Bind(&ClearKeyCdm::OnPromiseFailed, base::Unretained(this),
                  promise_id_for_emulated_loadsession_)));
   decryptor_->UpdateSession(
       session_id_for_emulated_loadsession_,
       std::vector<uint8_t>(jwk_set.begin(), jwk_set.end()), promise.Pass());
 }
 
 void ClearKeyCdm::OnSessionMessage(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) {
   DVLOG(1) << "OnSessionMessage: " << message.size();
 
   // Ignore the message when we are waiting to update the loadable session.
   if (session_id == session_id_for_emulated_loadsession_)
     return;
 
   // OnSessionMessage() only called during CreateSession(), so no promise
   // involved (OnSessionCreated() called to resolve the CreateSession()
   // promise).
@@ skipping 31 matching lines @@
                              keys_vector.size());
 }
 
 void ClearKeyCdm::OnSessionClosed(const std::string& session_id) {
   std::string new_session_id = session_id;
   if (new_session_id == session_id_for_emulated_loadsession_)
     new_session_id = std::string(kLoadableSessionId);
   host_->OnSessionClosed(new_session_id.data(), new_session_id.length());
 }
 
-void ClearKeyCdm::OnSessionCreated(uint32 promise_id,
+void ClearKeyCdm::OnSessionCreated(uint32_t promise_id,
                                    const std::string& session_id) {
   // Save the latest session ID for renewal and file IO test messages.
   last_session_id_ = session_id;
 
   host_->OnResolveNewSessionPromise(promise_id, session_id.data(),
                                     session_id.length());
 }
 
-void ClearKeyCdm::OnSessionLoaded(uint32 promise_id,
+void ClearKeyCdm::OnSessionLoaded(uint32_t promise_id,
                                   const std::string& session_id) {
   // Save the latest session ID for renewal and file IO test messages.
   last_session_id_ = session_id;
 
   // |decryptor_| created some session as |session_id|, but going forward
   // we need to map that to |kLoadableSessionId|, as that is what callers
   // expect.
   session_id_for_emulated_loadsession_ = session_id;
 
   // Delay LoadLoadableSession() to test the case where Decrypt*() calls are
   // made before the session is fully loaded.
-  const int64 kDelayToLoadSessionMs = 500;
+  const int64_t kDelayToLoadSessionMs = 500;
 
   // Defer resolving the promise until the session is loaded.
   promise_id_for_emulated_loadsession_ = promise_id;
 
   // Use the address of |session_id_for_emulated_loadsession_| as the timer
   // context so that we can call LoadLoadableSession() when the timer expires.
   host_->SetTimer(kDelayToLoadSessionMs, &session_id_for_emulated_loadsession_);
 }
 
 void ClearKeyCdm::OnLoadSessionUpdated() {
@@ skipping 18 matching lines @@
     keys_info.swap(keys_info_for_emulated_loadsession_);
     has_received_keys_change_event_for_emulated_loadsession_ = false;
     DCHECK(!keys_vector.empty());
     ConvertCdmKeysInfo(keys_info.get(), &keys_vector);
     host_->OnSessionKeysChange(kLoadableSessionId, strlen(kLoadableSessionId),
                                !keys_vector.empty(), keys_vector.data(),
                                keys_vector.size());
   }
 }
 
-void ClearKeyCdm::OnPromiseResolved(uint32 promise_id) {
+void ClearKeyCdm::OnPromiseResolved(uint32_t promise_id) {
   host_->OnResolvePromise(promise_id);
 }
 
-void ClearKeyCdm::OnPromiseFailed(uint32 promise_id,
+void ClearKeyCdm::OnPromiseFailed(uint32_t promise_id,
                                   MediaKeys::Exception exception_code,
-                                  uint32 system_code,
+                                  uint32_t system_code,
                                   const std::string& error_message) {
   host_->OnRejectPromise(promise_id,
                          ConvertException(exception_code),
                          system_code,
                          error_message.data(),
                          error_message.length());
 }
 
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
-int64 ClearKeyCdm::CurrentTimeStampInMicroseconds() const {
+int64_t ClearKeyCdm::CurrentTimeStampInMicroseconds() const {
   return output_timestamp_base_in_microseconds_ +
          base::Time::kMicrosecondsPerSecond *
          total_samples_generated_  / samples_per_second_;
 }
 
 int ClearKeyCdm::GenerateFakeAudioFramesFromDuration(
-    int64 duration_in_microseconds,
+    int64_t duration_in_microseconds,
     cdm::AudioFrames* audio_frames) const {
-  int64 samples_to_generate = static_cast<double>(samples_per_second_) *
-      duration_in_microseconds / base::Time::kMicrosecondsPerSecond + 0.5;
+  int64_t samples_to_generate = static_cast<double>(samples_per_second_) *
+                                    duration_in_microseconds /
+                                    base::Time::kMicrosecondsPerSecond +
+                                0.5;
   if (samples_to_generate <= 0)
     return 0;
 
-  int64 bytes_per_sample = channel_count_ * bits_per_channel_ / 8;
+  int64_t bytes_per_sample = channel_count_ * bits_per_channel_ / 8;
   // |frame_size| must be a multiple of |bytes_per_sample|.
-  int64 frame_size = bytes_per_sample * samples_to_generate;
+  int64_t frame_size = bytes_per_sample * samples_to_generate;
 
-  int64 timestamp = CurrentTimeStampInMicroseconds();
+  int64_t timestamp = CurrentTimeStampInMicroseconds();
 
   const int kHeaderSize = sizeof(timestamp) + sizeof(frame_size);
   audio_frames->SetFrameBuffer(host_->Allocate(kHeaderSize + frame_size));
   uint8_t* data = audio_frames->FrameBuffer()->Data();
 
   memcpy(data, &timestamp, sizeof(timestamp));
   data += sizeof(timestamp);
   memcpy(data, &frame_size, sizeof(frame_size));
   data += sizeof(frame_size);
   // You won't hear anything because we have all zeros here. But the video
   // should play just fine!
   memset(data, 0, frame_size);
 
   audio_frames->FrameBuffer()->SetSize(kHeaderSize + frame_size);
 
   return samples_to_generate;
 }
 
 cdm::Status ClearKeyCdm::GenerateFakeAudioFrames(
-    int64 timestamp_in_microseconds,
+    int64_t timestamp_in_microseconds,
     cdm::AudioFrames* audio_frames) {
   if (timestamp_in_microseconds == kNoTimestamp)
     return cdm::kNeedMoreData;
 
   // Return kNeedMoreData for the first frame because duration is unknown.
   if (output_timestamp_base_in_microseconds_ == kNoTimestamp) {
     output_timestamp_base_in_microseconds_ = timestamp_in_microseconds;
     return cdm::kNeedMoreData;
   }
 
@@ skipping 16 matching lines @@
 void ClearKeyCdm::OnFileIOTestComplete(bool success) {
   DVLOG(1) << __FUNCTION__ << ": " << success;
   std::string message = GetFileIOTestResultMessage(success);
   host_->OnSessionMessage(last_session_id_.data(), last_session_id_.length(),
                           cdm::kLicenseRequest, message.data(),
                           message.length(), NULL, 0);
   file_io_test_runner_.reset();
 }
 
 }  // namespace media