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

media/cdm/ppapi/clear_key_cdm.cc

Index: media/cdm/ppapi/clear_key_cdm.cc
diff --git a/media/cdm/ppapi/clear_key_cdm.cc b/media/cdm/ppapi/clear_key_cdm.cc
index d6702ca9fcba4b4919d32eb94fb903394d35144c..2b93d51ec66eda86ccd3ad56dfb67416adc26430 100644
--- a/media/cdm/ppapi/clear_key_cdm.cc
+++ b/media/cdm/ppapi/clear_key_cdm.cc
@@ -73,7 +73,7 @@ const char kHeartBeatHeader[] = "HEARTBEAT";
 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();
   }
 
@@ -82,7 +82,7 @@ static scoped_refptr<media::DecoderBuffer> CopyDecoderBufferFrom(
       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;
@@ -126,7 +126,7 @@ 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()";
 
@@ -198,9 +198,10 @@ ClearKeyCdm::ClearKeyCdm(cdm::Host* host)
 
 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_);
@@ -225,11 +226,11 @@ cdm::Status ClearKeyCdm::GenerateKeyRequest(const char* type, int type_size,
 }
 
 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_);
@@ -248,7 +249,7 @@ cdm::Status ClearKeyCdm::AddKey(const char* session_id,
 }
 
 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_);
@@ -399,7 +400,7 @@ cdm::Status ClearKeyCdm::DecryptAndDecodeFrame(
     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();
@@ -423,7 +424,7 @@ cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
 
 #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();
@@ -515,18 +516,18 @@ int64 ClearKeyCdm::CurrentTimeStampInMicroseconds() const {
 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();