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 56 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(!input_buffer.data_size);
     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 (std::string(key_system, key_system_size) != kExternalClearKeyKeySystem) {
     DVLOG(1) << "Unsupported key system.";
     return NULL;
   }
 
   if (cdm_interface_version != cdm::ContentDecryptionModule_2::kVersion)
     return NULL;
 
-  cdm::Host* host = static_cast<cdm::Host*>(
-      get_cdm_host_func(cdm::ContentDecryptionModule_2::kVersion, user_data));
+  cdm::ContentDecryptionModule_2::Host* host =
+      static_cast<cdm::ContentDecryptionModule_2::Host*>(get_cdm_host_func(
+          cdm::ContentDecryptionModule_2::Host::kVersion, user_data));
   if (!host)
     return NULL;
 
   return new media::ClearKeyCdm(host);
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
@@ skipping 42 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 296 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