Switch CdmWrapper to use uint32_t for size types per style guide.

media/cdm/ppapi/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/clear_key_cdm.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <vector>
@@ skipping 55 matching lines @@
 const int64 kMaxTimerDelayMs = 1 * kSecondsPerMinute * kMsPerSecond;
 // Heart beat message header. If a key message starts with |kHeartBeatHeader|,
 // it's a heart beat message. Otherwise, it's a key request.
 const char kHeartBeatHeader[] = "HEARTBEAT";
 
 // 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(
     const cdm::InputBuffer& input_buffer) {
   if (!input_buffer.data) {
-    DCHECK_EQ(input_buffer.data_size, 0);
+    DCHECK_EQ(input_buffer.data_size, 0u);
     return media::DecoderBuffer::CreateEOSBuffer();
   }
 
   // TODO(tomfinegan): Get rid of this copy.
   scoped_refptr<media::DecoderBuffer> output_buffer =
       media::DecoderBuffer::CopyFrom(input_buffer.data, input_buffer.data_size);
 
   std::vector<media::SubsampleEntry> subsamples;
-  for (int32_t i = 0; i < input_buffer.num_subsamples; ++i) {
+  for (uint32_t i = 0; i < input_buffer.num_subsamples; ++i) {
     media::SubsampleEntry subsample;
     subsample.clear_bytes = input_buffer.subsamples[i].clear_bytes;
     subsample.cypher_bytes = input_buffer.subsamples[i].cipher_bytes;
     subsamples.push_back(subsample);
   }
 
   scoped_ptr<media::DecryptConfig> decrypt_config(new media::DecryptConfig(
       std::string(reinterpret_cast<const char*>(input_buffer.key_id),
                   input_buffer.key_id_size),
       std::string(reinterpret_cast<const char*>(input_buffer.iv),
@@ skipping 23 matching lines @@
   DVLOG(2) << "FFmpeg libraries initialized: " << g_ffmpeg_lib_initialized;
   av_register_all();
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 void DeinitializeCdmModule() {
 }
 
 void* CreateCdmInstance(
     int cdm_interface_version,
-    const char* key_system, int key_system_size,
+    const char* key_system, uint32_t key_system_size,
     GetCdmHostFunc get_cdm_host_func, void* user_data) {
   DVLOG(1) << "CreateCdmInstance()";
 
   if (cdm_interface_version != cdm::kCdmInterfaceVersion)
     return NULL;
 
   cdm::Host* host = static_cast<cdm::Host*>(
       get_cdm_host_func(cdm::kHostInterfaceVersion, user_data));
   if (!host)
     return NULL;
@@ skipping 51 matching lines @@
   channel_count_ = 0;
   bits_per_channel_ = 0;
   samples_per_second_ = 0;
   output_timestamp_base_in_microseconds_ = kNoTimestamp;
   total_samples_generated_ = 0;
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
-cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type, int type_size,
+cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type,
+                                            uint32_t type_size,
                                             const uint8_t* init_data,
-                                            int init_data_size) {
+                                            uint32_t init_data_size) {
   DVLOG(1) << "GenerateKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
   decryptor_.GenerateKeyRequest(std::string(type, type_size),
                                 init_data, init_data_size);
 
   if (client_.status() != Client::kKeyMessage) {
     host_->SendKeyError(NULL, 0, cdm::kUnknownError, 0);
     return cdm::kSessionError;
   }
 
   host_->SendKeyMessage(
       client_.session_id().data(), client_.session_id().size(),
       reinterpret_cast<const char*>(&client_.key_message()[0]),
       client_.key_message().size(),
       client_.default_url().data(), client_.default_url().size());
 
   // Only save the latest session ID for heartbeat messages.
   heartbeat_session_id_ = client_.session_id();
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::AddKey(const char* session_id,
-                                int session_id_size,
+                                uint32_t session_id_size,
                                 const uint8_t* key,
-                                int key_size,
+                                uint32_t key_size,
                                 const uint8_t* key_id,
-                                int key_id_size) {
+                                uint32_t key_id_size) {
   DVLOG(1) << "AddKey()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
   decryptor_.AddKey(key, key_size, key_id, key_id_size,
                     std::string(session_id, session_id_size));
 
   if (client_.status() != Client::kKeyAdded)
     return cdm::kSessionError;
 
   if (!timer_set_) {
     ScheduleNextHeartBeat();
     timer_set_ = true;
   }
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::CancelKeyRequest(const char* session_id,
-                                          int session_id_size) {
+                                          uint32_t session_id_size) {
   DVLOG(1) << "CancelKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
   decryptor_.CancelKeyRequest(std::string(session_id, session_id_size));
   return cdm::kSuccess;
 }
 
 void ClearKeyCdm::TimerExpired(void* context) {
   std::string heartbeat_message;
   if (!next_heartbeat_message_.empty() &&
@@ skipping 130 matching lines @@
   DVLOG(1) << "DecryptAndDecodeFrame()";
   TRACE_EVENT0("eme", "ClearKeyCdm::DecryptAndDecodeFrame");
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
   const uint8_t* data = NULL;
-  int32_t size = 0;
+  uint32_t size = 0;
   int64_t timestamp = 0;
   if (!buffer->end_of_stream()) {
     data = buffer->data();
     size = buffer->data_size();
     timestamp = encrypted_buffer.timestamp;
   }
 
   return video_decoder_->DecodeFrame(data, size, timestamp, decoded_frame);
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
     const cdm::InputBuffer& encrypted_buffer,
     cdm::AudioFrames* audio_frames) {
   DVLOG(1) << "DecryptAndDecodeSamples()";
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
 #if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
   const uint8_t* data = NULL;
-  int32_t size = 0;
+  uint32_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;
@@ skipping 71 matching lines @@
 #if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
 int64 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,
     cdm::AudioFrames* audio_frames) const {
-  int64 samples_to_generate = static_cast<double>(samples_per_second_) *
+  int samples_to_generate = static_cast<double>(samples_per_second_) *

[ddorwin, 2013/10/08 23:53:20]

should we do the calculation, check <= MAX_UINT, then cast?

       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;
+  uint32_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;
+  uint32_t frame_size = bytes_per_sample * samples_to_generate;
 
   int64 timestamp = CurrentTimeStampInMicroseconds();
 
-  const int kHeaderSize = sizeof(timestamp) + sizeof(frame_size);
+  const uint32_t 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);
@@ skipping 18 matching lines @@
   int samples_generated = GenerateFakeAudioFramesFromDuration(
       timestamp_in_microseconds - CurrentTimeStampInMicroseconds(),
       audio_frames);
   total_samples_generated_ += samples_generated;
 
   return samples_generated == 0 ? cdm::kNeedMoreData : cdm::kSuccess;
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 
 }  // namespace media