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

media/cdm/ppapi/cdm_adapter.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/cdm_adapter.h"
 
 #include "media/cdm/ppapi/cdm_helpers.h"
 
 #if defined(CHECK_DOCUMENT_URL)
 #include "ppapi/cpp/dev/url_util_dev.h"
@@ skipping 28 matching lines @@
 void ConfigureInputBuffer(
     const pp::Buffer_Dev& encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info,
     std::vector<cdm::SubsampleEntry>* subsamples,
     cdm::InputBuffer* input_buffer) {
   PP_DCHECK(subsamples);
   PP_DCHECK(!encrypted_buffer.is_null());
 
   input_buffer->data = static_cast<uint8_t*>(encrypted_buffer.data());
   input_buffer->data_size = encrypted_block_info.data_size;
-  PP_DCHECK(encrypted_buffer.size() >=
-            static_cast<uint32_t>(input_buffer->data_size));
+  PP_DCHECK(encrypted_buffer.size() >= input_buffer->data_size);
   input_buffer->data_offset = encrypted_block_info.data_offset;
 
   PP_DCHECK(encrypted_block_info.key_id_size <=
             arraysize(encrypted_block_info.key_id));
   input_buffer->key_id_size = encrypted_block_info.key_id_size;
   input_buffer->key_id = input_buffer->key_id_size > 0 ?
       encrypted_block_info.key_id : NULL;
 
   PP_DCHECK(encrypted_block_info.iv_size <= arraysize(encrypted_block_info.iv));
   input_buffer->iv_size = encrypted_block_info.iv_size;
@@ skipping 215 matching lines @@
                         pp::VarArrayBuffer key,
                         pp::VarArrayBuffer init_data) {
   // TODO(jrummell): In EME WD, AddKey() can only be called on valid sessions.
   // We should be able to DCHECK(cdm_) when addressing http://crbug.com/249976.
   if (!cdm_) {
     SendUnknownKeyError(key_system_, session_id);
     return;
   }
 
   const uint8_t* key_ptr = static_cast<const uint8_t*>(key.Map());
-  int key_size = key.ByteLength();
+  const uint32_t key_size = key.ByteLength();
   const uint8_t* init_data_ptr = static_cast<const uint8_t*>(init_data.Map());
-  int init_data_size = init_data.ByteLength();
+  const uint32_t init_data_size = init_data.ByteLength();
   PP_DCHECK(!init_data_ptr == !init_data_size);
 
-  if (!key_ptr || key_size <= 0) {
+  if (!key_ptr || !key_size) {
     SendUnknownKeyError(key_system_, session_id);
     return;
   }
 
   cdm::Status status = cdm_->AddKey(session_id.data(), session_id.size(),
                                     key_ptr, key_size,
                                     init_data_ptr, init_data_size);
   PP_DCHECK(status == cdm::kSuccess || status == cdm::kSessionError);
   if (status != cdm::kSuccess) {
     SendUnknownKeyError(key_system_, session_id);
@@ skipping 55 matching lines @@
   cdm::Status status = cdm::kSessionError;
   if (cdm_) {
     cdm::AudioDecoderConfig cdm_decoder_config;
     cdm_decoder_config.codec =
         PpAudioCodecToCdmAudioCodec(decoder_config.codec);
     cdm_decoder_config.channel_count = decoder_config.channel_count;
     cdm_decoder_config.bits_per_channel = decoder_config.bits_per_channel;
     cdm_decoder_config.samples_per_second = decoder_config.samples_per_second;
     cdm_decoder_config.extra_data =
         static_cast<uint8_t*>(extra_data_buffer.data());
-    cdm_decoder_config.extra_data_size =
-        static_cast<int32_t>(extra_data_buffer.size());
+    cdm_decoder_config.extra_data_size = extra_data_buffer.size();
     status = cdm_->InitializeAudioDecoder(cdm_decoder_config);
   }
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmAdapter::DecoderInitializeDone,
       PP_DECRYPTORSTREAMTYPE_AUDIO,
       decoder_config.request_id,
       status == cdm::kSuccess));
 }
 
 void CdmAdapter::InitializeVideoDecoder(
     const PP_VideoDecoderConfig& decoder_config,
     pp::Buffer_Dev extra_data_buffer) {
   cdm::Status status = cdm::kSessionError;
   if (cdm_) {
     cdm::VideoDecoderConfig cdm_decoder_config;
     cdm_decoder_config.codec =
         PpVideoCodecToCdmVideoCodec(decoder_config.codec);
     cdm_decoder_config.profile =
         PpVCProfileToCdmVCProfile(decoder_config.profile);
     cdm_decoder_config.format =
         PpDecryptedFrameFormatToCdmVideoFormat(decoder_config.format);
     cdm_decoder_config.coded_size.width = decoder_config.width;
     cdm_decoder_config.coded_size.height = decoder_config.height;
     cdm_decoder_config.extra_data =
         static_cast<uint8_t*>(extra_data_buffer.data());
-    cdm_decoder_config.extra_data_size =
-        static_cast<int32_t>(extra_data_buffer.size());
+    cdm_decoder_config.extra_data_size = extra_data_buffer.size();
     status = cdm_->InitializeVideoDecoder(cdm_decoder_config);
   }
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmAdapter::DecoderInitializeDone,
       PP_DECRYPTORSTREAMTYPE_VIDEO,
       decoder_config.request_id,
       status == cdm::kSuccess));
 }
 
@@ skipping 67 matching lines @@
           encrypted_block_info.tracking_info));
       return;
     }
 
     default:
       PP_NOTREACHED();
       return;
   }
 }
 
-cdm::Buffer* CdmAdapter::Allocate(int32_t capacity) {
+cdm::Buffer* CdmAdapter::Allocate(uint32_t capacity) {
   return allocator_.Allocate(capacity);
 }
 
 void CdmAdapter::SetTimer(int64_t delay_ms, void* context) {
   // NOTE: doesn't really need to run on the main thread; could just as well run
   // on a helper thread if |cdm_| were thread-friendly and care was taken.  We
   // only use CallOnMainThread() here to get delayed-execution behavior.
   pp::Module::Get()->core()->CallOnMainThread(
       delay_ms,
       callback_factory_.NewCallback(&CdmAdapter::TimerExpired, context),
       PP_OK);
 }
 
 void CdmAdapter::TimerExpired(int32_t result, void* context) {
   PP_DCHECK(result == PP_OK);
   cdm_->TimerExpired(context);
 }
 
 double CdmAdapter::GetCurrentWallTimeInSeconds() {
   return pp::Module::Get()->core()->GetTime();
 }
 
 void CdmAdapter::SendKeyMessage(
-    const char* session_id, int32_t session_id_length,
-    const char* message, int32_t message_length,
-    const char* default_url, int32_t default_url_length) {
+    const char* session_id, uint32_t session_id_length,
+    const char* message, uint32_t message_length,
+    const char* default_url, uint32_t default_url_length) {
   PP_DCHECK(!key_system_.empty());
   PostOnMain(callback_factory_.NewCallback(
       &CdmAdapter::KeyMessage,
       SessionInfo(key_system_,
                   std::string(session_id, session_id_length)),
       std::vector<uint8>(message, message + message_length),
       std::string(default_url, default_url_length)));
 }
 
 void CdmAdapter::SendKeyError(const char* session_id,
-                              int32_t session_id_length,
+                              uint32_t session_id_length,
                               cdm::MediaKeyError error_code,
                               uint32_t system_code) {
   SendKeyErrorInternal(key_system_,
                        std::string(session_id, session_id_length),
                        error_code,
                        system_code);
 }
 
 void CdmAdapter::GetPrivateData(int32_t* instance,
                                 GetPrivateInterface* get_interface) {
@@ skipping 194 matching lines @@
 bool CdmAdapter::IsValidVideoFrame(const LinkedVideoFrame& video_frame) {
   if (!video_frame.get() ||
       !video_frame->FrameBuffer() ||
       (video_frame->Format() != cdm::kI420 &&
        video_frame->Format() != cdm::kYv12)) {
     return false;
   }
 
   PpbBuffer* ppb_buffer = static_cast<PpbBuffer*>(video_frame->FrameBuffer());
 
-  for (int i = 0; i < cdm::VideoFrame::kMaxPlanes; ++i) {
+  for (uint32_t i = 0; i < cdm::VideoFrame::kMaxPlanes; ++i) {
     int plane_height = (i == cdm::VideoFrame::kYPlane) ?
         video_frame->Size().height : (video_frame->Size().height + 1) / 2;
     cdm::VideoFrame::VideoPlane plane =
         static_cast<cdm::VideoFrame::VideoPlane>(i);
     if (ppb_buffer->Size() < video_frame->PlaneOffset(plane) +
                              plane_height * video_frame->Stride(plane)) {
       return false;
     }
   }
 
   return true;
 }
 
+void CdmAdapter::OnDeferredInitializationDone(cdm::StreamType stream_type,
+                                              cdm::Status decoder_status) {
+  PP_NOTREACHED();
+}
+
 void CdmAdapter::SendPlatformChallenge(
-    const char* service_id, int32_t service_id_length,
-    const char* challenge, int32_t challenge_length) {
+    const char* service_id, uint32_t service_id_length,
+    const char* challenge, uint32_t challenge_length) {
 #if defined(OS_CHROMEOS)
   PP_DCHECK(!challenge_in_progress_);
 
   // Ensure member variables set by the callback are in a clean state.
   signed_data_output_ = pp::Var();
   signed_data_signature_output_ = pp::Var();
   platform_key_certificate_output_ = pp::Var();
 
   pp::VarArrayBuffer challenge_var(challenge_length);
   uint8_t* var_data = static_cast<uint8_t*>(challenge_var.Map());
@@ skipping 62 matching lines @@
     return;
   }
 
   pp::VarArrayBuffer signed_data_var(signed_data_output_);
   pp::VarArrayBuffer signed_data_signature_var(signed_data_signature_output_);
   std::string platform_key_certificate_string =
       platform_key_certificate_output_.AsString();
 
   cdm::PlatformChallengeResponse response = {
     static_cast<uint8_t*>(signed_data_var.Map()),
-    static_cast<int32_t>(signed_data_var.ByteLength()),
+    signed_data_var.ByteLength(),
 
     static_cast<uint8_t*>(signed_data_signature_var.Map()),
-    static_cast<int32_t>(signed_data_signature_var.ByteLength()),
+    signed_data_signature_var.ByteLength(),
 
     reinterpret_cast<const uint8_t*>(platform_key_certificate_string.c_str()),
-    static_cast<int32_t>(platform_key_certificate_string.length())
+    static_cast<uint32_t>(platform_key_certificate_string.length())
   };
   cdm_->OnPlatformChallengeResponse(response);
 
   signed_data_var.Unmap();
   signed_data_signature_var.Unmap();
 }
 
 void CdmAdapter::EnableProtectionDone(int32_t result) {
   // Does nothing since clients must call QueryOutputProtectionStatus() to
   // inspect the protection status on a regular basis.
@@ skipping 50 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp