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

media/cdm/ppapi/cdm_wrapper.h

 // 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.
 
 #ifndef MEDIA_CDM_PPAPI_CDM_WRAPPER_H_
 #define MEDIA_CDM_PPAPI_CDM_WRAPPER_H_
 
 #include "base/basictypes.h"
 #include "media/cdm/ppapi/api/content_decryption_module.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
@@ skipping 13 matching lines @@
 // calls to corresponding ContentDecryptionModule calls.
 //
 // Note that CdmWrapper interface always reflects the latest state of content
 // decryption related PPAPI APIs (e.g. pp::ContentDecryptor_Private).
 //
 // Since this file is highly templated and default implementations are short
 // (just a shim layer in most cases), everything is done in this header file.
 class CdmWrapper {
  public:
   static CdmWrapper* Create(const char* key_system,
-                            int key_system_size,
+                            uint32_t key_system_size,
                             GetCdmHostFunc get_cdm_host_func,
                             void* user_data);
 
   virtual ~CdmWrapper() {};
 
   virtual cdm::Status GenerateKeyRequest(const char* type,
-                                         int type_size,
+                                         uint32_t type_size,
                                          const uint8_t* init_data,
-                                         int init_data_size) = 0;
+                                         uint32_t init_data_size) = 0;
   virtual cdm::Status 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) = 0;
+                             uint32_t key_id_size) = 0;
   virtual cdm::Status CancelKeyRequest(const char* session_id,
-                                       int session_id_size) = 0;
+                                       uint32_t session_id_size) = 0;
   virtual void TimerExpired(void* context) = 0;
   virtual cdm::Status Decrypt(const cdm::InputBuffer& encrypted_buffer,
                               cdm::DecryptedBlock* decrypted_buffer) = 0;
   virtual cdm::Status InitializeAudioDecoder(
       const cdm::AudioDecoderConfig& audio_decoder_config) = 0;
   virtual cdm::Status InitializeVideoDecoder(
       const cdm::VideoDecoderConfig& video_decoder_config) = 0;
   virtual void DeinitializeDecoder(cdm::StreamType decoder_type) = 0;
   virtual void ResetDecoder(cdm::StreamType decoder_type) = 0;
   virtual cdm::Status DecryptAndDecodeFrame(
@@ skipping 15 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CdmWrapper);
 };
 
 // Template class that does the CdmWrapper -> CdmInterface conversion. Default
 // implementations are provided. Any methods that need special treatment should
 // be specialized.
 template <class CdmInterface>
 class CdmWrapperImpl : public CdmWrapper {
  public:
   static CdmWrapper* Create(const char* key_system,
-                            int key_system_size,
+                            uint32_t key_system_size,
                             GetCdmHostFunc get_cdm_host_func,
                             void* user_data) {
     void* cdm_instance = ::CreateCdmInstance(
         CdmInterface::kVersion, key_system, key_system_size, get_cdm_host_func,
         user_data);
     if (!cdm_instance)
       return NULL;
 
     return new CdmWrapperImpl<CdmInterface>(
         static_cast<CdmInterface*>(cdm_instance));
   }
 
   virtual ~CdmWrapperImpl() {
     cdm_->Destroy();
   }
 
   virtual cdm::Status GenerateKeyRequest(const char* type,
-                                         int type_size,
+                                         uint32_t type_size,
                                          const uint8_t* init_data,
-                                         int init_data_size) OVERRIDE {
+                                         uint32_t init_data_size) OVERRIDE {
     return cdm_->GenerateKeyRequest(type, type_size, init_data, init_data_size);
   }
 
   virtual cdm::Status 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) OVERRIDE {
+                             uint32_t key_id_size) OVERRIDE {
     return cdm_->AddKey(
         session_id, session_id_size, key, key_size, key_id, key_id_size);
   }
 
   virtual cdm::Status CancelKeyRequest(const char* session_id,
-                                       int session_id_size) OVERRIDE {
+                                       uint32_t session_id_size) OVERRIDE {
     return cdm_->CancelKeyRequest(session_id, session_id_size);
   }
 
   virtual void TimerExpired(void* context) OVERRIDE {
     cdm_->TimerExpired(context);
   }
 
   virtual cdm::Status Decrypt(const cdm::InputBuffer& encrypted_buffer,
                               cdm::DecryptedBlock* decrypted_buffer) OVERRIDE {
     return cdm_->Decrypt(encrypted_buffer, decrypted_buffer);
@@ skipping 72 matching lines @@
       cdm_->DecryptAndDecodeSamples(encrypted_buffer, &audio_frames_1);
   if (status != cdm::kSuccess)
     return status;
 
   audio_frames->SetFrameBuffer(audio_frames_1.PassFrameBuffer());
   audio_frames->SetFormat(cdm::kAudioFormatS16);
   return cdm::kSuccess;
 }
 
 CdmWrapper* CdmWrapper::Create(const char* key_system,
-                               int key_system_size,
+                               uint32_t key_system_size,
                                GetCdmHostFunc get_cdm_host_func,
                                void* user_data) {
   // Try to create the CDM using the latest CDM interface version.
   CdmWrapper* cdm_adapter =
       CdmWrapperImpl<cdm::ContentDecryptionModule>::Create(
           key_system, key_system_size, get_cdm_host_func, user_data);
   if (cdm_adapter)
     return cdm_adapter;
 
   // Try to see if the CDM supports older version(s) of CDM interface(s).
   cdm_adapter = CdmWrapperImpl<cdm::ContentDecryptionModule_1>::Create(
       key_system, key_system_size, get_cdm_host_func, user_data);
   return cdm_adapter;
 }
 
 // When updating the CdmAdapter, ensure you've updated the CdmWrapper to contain
 // stub implementations for new or modified methods which the older CDM
 // interface does not have.
 COMPILE_ASSERT(cdm::ContentDecryptionModule_2::kVersion ==
                    cdm::ContentDecryptionModule::kVersion,
                ensure_cdm_wrapper_templates_have_old_version_support);
 
 }  // namespace media
 
 #endif  // MEDIA_CDM_PPAPI_CDM_WRAPPER_H_