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

media/cdm/ppapi/cdm_wrapper.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 <cstring>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 57 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 133 matching lines @@
   static PpbBuffer* Create(const pp::Buffer_Dev& buffer, uint32_t buffer_id) {
     PP_DCHECK(buffer.data());
     PP_DCHECK(buffer.size());
     PP_DCHECK(buffer_id);
     return new PpbBuffer(buffer, buffer_id);
   }
 
   // cdm::Buffer implementation.
   virtual void Destroy() OVERRIDE { delete this; }
 
-  virtual int32_t Capacity() const OVERRIDE { return buffer_.size(); }
+  virtual uint32_t Capacity() const OVERRIDE { return buffer_.size(); }
 
   virtual uint8_t* Data() OVERRIDE {
     return static_cast<uint8_t*>(buffer_.data());
   }
 
-  virtual void SetSize(int32_t size) OVERRIDE {
-    PP_DCHECK(size >= 0);
+  virtual void SetSize(uint32_t size) OVERRIDE {
     PP_DCHECK(size < Capacity());
-    if (size < 0 || size > Capacity()) {
+    if (size > Capacity()) {
       size_ = 0;
       return;
     }
 
     size_ = size;
   }
 
-  virtual int32_t Size() const OVERRIDE { return size_; }
+  virtual uint32_t Size() const OVERRIDE { return size_; }
 
   pp::Buffer_Dev buffer_dev() const { return buffer_; }
 
   uint32_t buffer_id() const { return buffer_id_; }
 
  private:
   PpbBuffer(pp::Buffer_Dev buffer, uint32_t buffer_id)
       : buffer_(buffer),
         buffer_id_(buffer_id),
         size_(0) {}
   virtual ~PpbBuffer() {}
 
   pp::Buffer_Dev buffer_;
   uint32_t buffer_id_;
-  int32_t size_;
+  uint32_t size_;
 
   DISALLOW_COPY_AND_ASSIGN(PpbBuffer);
 };
 
 class PpbBufferAllocator {
  public:
   explicit PpbBufferAllocator(pp::Instance* instance)
       : instance_(instance),
         next_buffer_id_(1) {}
   ~PpbBufferAllocator() {}
 
-  cdm::Buffer* Allocate(int32_t capacity);
+  cdm::Buffer* Allocate(uint32_t capacity);
 
   // Releases the buffer with |buffer_id|. A buffer can be recycled after
   // it is released.
   void Release(uint32_t buffer_id);
 
  private:
   typedef std::map<uint32_t, pp::Buffer_Dev> AllocatedBufferMap;
-  typedef std::multimap<int, std::pair<uint32_t, pp::Buffer_Dev> >
+  typedef std::multimap<uint32_t, std::pair<uint32_t, pp::Buffer_Dev> >
       FreeBufferMap;
 
   // Always pad new allocated buffer so that we don't need to reallocate
   // buffers frequently if requested sizes fluctuate slightly.
-  static const int kBufferPadding = 512;
+  static const uint32_t kBufferPadding = 512;
 
   // Maximum number of free buffers we can keep when allocating new buffers.
-  static const int kFreeLimit = 3;
+  static const uint32_t kFreeLimit = 3;
 
-  pp::Buffer_Dev AllocateNewBuffer(int capacity);
+  pp::Buffer_Dev AllocateNewBuffer(uint32_t capacity);
 
   pp::Instance* const instance_;
   uint32_t next_buffer_id_;
   AllocatedBufferMap allocated_buffers_;
   FreeBufferMap free_buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(PpbBufferAllocator);
 };
 
-cdm::Buffer* PpbBufferAllocator::Allocate(int32_t capacity) {
+cdm::Buffer* PpbBufferAllocator::Allocate(uint32_t capacity) {
   PP_DCHECK(IsMainThread());
 
-  if (capacity <= 0)
+  if (!capacity)
     return NULL;
 
   pp::Buffer_Dev buffer;
   uint32_t buffer_id = 0;
 
   // Reuse a buffer in the free list if there is one that fits |capacity|.
   // Otherwise, create a new one.
   FreeBufferMap::iterator found = free_buffers_.lower_bound(capacity);
   if (found == free_buffers_.end()) {
     // TODO(xhwang): Report statistics about how many new buffers are allocated.
@@ skipping 20 matching lines @@
   if (found == allocated_buffers_.end())
     return;
 
   pp::Buffer_Dev& buffer = found->second;
   free_buffers_.insert(
       std::make_pair(buffer.size(), std::make_pair(buffer_id, buffer)));
 
   allocated_buffers_.erase(found);
 }
 
-pp::Buffer_Dev PpbBufferAllocator::AllocateNewBuffer(int32_t capacity) {
+pp::Buffer_Dev PpbBufferAllocator::AllocateNewBuffer(uint32_t capacity) {
   // Destroy the smallest buffer before allocating a new bigger buffer if the
   // number of free buffers exceeds a limit. This mechanism helps avoid ending
   // up with too many small buffers, which could happen if the size to be
   // allocated keeps increasing.
-  if (free_buffers_.size() >= static_cast<uint32_t>(kFreeLimit))
+  if (free_buffers_.size() >= kFreeLimit)
     free_buffers_.erase(free_buffers_.begin());
 
   // Creation of pp::Buffer_Dev is expensive! It involves synchronous IPC calls.
   // That's why we try to avoid AllocateNewBuffer() as much as we can.
   return pp::Buffer_Dev(instance_, capacity + kBufferPadding);
 }
 
 class DecryptedBlockImpl : public cdm::DecryptedBlock {
  public:
   DecryptedBlockImpl() : buffer_(NULL), timestamp_(0) {}
@@ skipping 28 matching lines @@
 
   virtual void SetSize(cdm::Size size) OVERRIDE { size_ = size; }
   virtual cdm::Size Size() const OVERRIDE { return size_; }
 
   virtual void SetFrameBuffer(cdm::Buffer* frame_buffer) OVERRIDE {
     frame_buffer_ = static_cast<PpbBuffer*>(frame_buffer);
   }
   virtual cdm::Buffer* FrameBuffer() OVERRIDE { return frame_buffer_; }
 
   virtual void SetPlaneOffset(cdm::VideoFrame::VideoPlane plane,
-                              int32_t offset) OVERRIDE {
-    PP_DCHECK(0 <= plane && plane < kMaxPlanes);
-    PP_DCHECK(offset >= 0);
+                              uint32_t offset) OVERRIDE {
+    PP_DCHECK(plane < kMaxPlanes);
     plane_offsets_[plane] = offset;
   }
-  virtual int32_t PlaneOffset(VideoPlane plane) OVERRIDE {
-    PP_DCHECK(0 <= plane && plane < kMaxPlanes);
+  virtual uint32_t PlaneOffset(VideoPlane plane) OVERRIDE {
+    PP_DCHECK(plane < kMaxPlanes);
     return plane_offsets_[plane];
   }
 
-  virtual void SetStride(VideoPlane plane, int32_t stride) OVERRIDE {
-    PP_DCHECK(0 <= plane && plane < kMaxPlanes);
+  virtual void SetStride(VideoPlane plane, uint32_t stride) OVERRIDE {
+    PP_DCHECK(plane < kMaxPlanes);
     strides_[plane] = stride;
   }
-  virtual int32_t Stride(VideoPlane plane) OVERRIDE {
-    PP_DCHECK(0 <= plane && plane < kMaxPlanes);
+  virtual uint32_t Stride(VideoPlane plane) OVERRIDE {
+    PP_DCHECK(plane < kMaxPlanes);
     return strides_[plane];
   }
 
   virtual void SetTimestamp(int64_t timestamp) OVERRIDE {
     timestamp_ = timestamp;
   }
   virtual int64_t Timestamp() const OVERRIDE { return timestamp_; }
 
  private:
   // The video buffer format.
   cdm::VideoFormat format_;
 
   // Width and height of the video frame.
   cdm::Size size_;
 
   // The video frame buffer.
   PpbBuffer* frame_buffer_;
 
   // Array of data pointers to each plane in the video frame buffer.
-  int32_t plane_offsets_[kMaxPlanes];
+  uint32_t plane_offsets_[kMaxPlanes];
 
   // Array of strides for each plane, typically greater or equal to the width
   // of the surface divided by the horizontal sampling period.  Note that
   // strides can be negative.
-  int32_t strides_[kMaxPlanes];
+  uint32_t strides_[kMaxPlanes];
 
   // Presentation timestamp in microseconds.
   int64_t timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameImpl);
 };
 
 VideoFrameImpl::VideoFrameImpl()
     : format_(cdm::kUnknownVideoFormat),
       frame_buffer_(NULL),
       timestamp_(0) {
-  for (int32_t i = 0; i < kMaxPlanes; ++i) {
+  for (uint32_t i = 0; i < kMaxPlanes; ++i) {
     plane_offsets_[i] = 0;
     strides_[i] = 0;
   }
 }
 
 VideoFrameImpl::~VideoFrameImpl() {
   if (frame_buffer_)
     frame_buffer_->Destroy();
 }
 
@@ skipping 68 matching lines @@
   virtual void DeinitializeDecoder(PP_DecryptorStreamType decoder_type,
                                    uint32_t request_id) OVERRIDE;
   virtual void ResetDecoder(PP_DecryptorStreamType decoder_type,
                             uint32_t request_id) OVERRIDE;
   virtual void DecryptAndDecode(
       PP_DecryptorStreamType decoder_type,
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
 
   // cdm::Host_1 implementation.
-  virtual cdm::Buffer* Allocate(int32_t capacity) OVERRIDE;
+  virtual cdm::Buffer* Allocate(uint32_t capacity) OVERRIDE;
   virtual void SetTimer(int64_t delay_ms, void* context) OVERRIDE;
   virtual double GetCurrentWallTimeInSeconds() OVERRIDE;
   virtual void 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) OVERRIDE;
+      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) OVERRIDE;
   virtual void SendKeyError(const char* session_id,
-                            int32_t session_id_length,
+                            uint32_t session_id_length,
                             cdm::MediaKeyError error_code,
                             uint32_t system_code) OVERRIDE;
   virtual void GetPrivateData(int32_t* instance,
                               GetPrivateInterface* get_interface) OVERRIDE;
 
   // cdm::Host_2 implementation.
   virtual bool CanChallengePlatform() OVERRIDE;
   virtual void SendPlatformChallenge(
-      const char* service_id, int32_t service_id_length,
-      const char* challenge, int32_t challenge_length) OVERRIDE;
+      const char* service_id, uint32_t service_id_length,
+      const char* challenge, uint32_t challenge_length) OVERRIDE;
   virtual void EnableOutputProtection(
       uint32_t desired_protection_mask) OVERRIDE;
   virtual void QueryOutputProtectionStatus() OVERRIDE;
 
  private:
   struct SessionInfo {
     SessionInfo(const std::string& key_system_in,
                 const std::string& session_id_in)
         : key_system(key_system_in),
           session_id(session_id_in) {}
@@ skipping 176 matching lines @@
 void CdmWrapper::AddKey(const std::string& session_id,
                         pp::VarArrayBuffer key,
                         pp::VarArrayBuffer init_data) {
   PP_DCHECK(cdm_);  // Initialize() should have succeeded.
   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();
+  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();
+  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 57 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(
       &CdmWrapper::DecoderInitializeDone,
       PP_DECRYPTORSTREAMTYPE_AUDIO,
       decoder_config.request_id,
       status == cdm::kSuccess));
 }
 
 void CdmWrapper::InitializeVideoDecoder(
     const PP_VideoDecoderConfig& decoder_config,
     pp::Buffer_Dev extra_data_buffer) {
   PP_DCHECK(cdm_);  // Initialize() should have succeeded.
 
   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(
       &CdmWrapper::DecoderInitializeDone,
       PP_DECRYPTORSTREAMTYPE_VIDEO,
       decoder_config.request_id,
       status == cdm::kSuccess));
 }
 
@@ skipping 68 matching lines @@
           encrypted_block_info.tracking_info));
       return;
     }
 
     default:
       PP_NOTREACHED();
       return;
   }
 }
 
-cdm::Buffer* CdmWrapper::Allocate(int32_t capacity) {
+cdm::Buffer* CdmWrapper::Allocate(uint32_t capacity) {
   return allocator_.Allocate(capacity);
 }
 
 void CdmWrapper::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(&CdmWrapper::TimerExpired, context),
       PP_OK);
 }
 
 void CdmWrapper::TimerExpired(int32_t result, void* context) {
   PP_DCHECK(result == PP_OK);
   cdm_->TimerExpired(context);
 }
 
 double CdmWrapper::GetCurrentWallTimeInSeconds() {
   return pp::Module::Get()->core()->GetTime();
 }
 
 void CdmWrapper::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(
       &CdmWrapper::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 CdmWrapper::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 CdmWrapper::GetPrivateData(int32_t* instance,
                                 GetPrivateInterface* get_interface) {
@@ skipping 194 matching lines @@
 bool CdmWrapper::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;
 }
 
 bool CdmWrapper::CanChallengePlatform() {
 #if defined(OS_CHROMEOS)
   return can_challenge_platform_;
 #else
   return false;
 #endif
 }
 
 void CdmWrapper::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 67 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 CdmWrapper::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::CdmWrapperModule();
 }
 
 }  // namespace pp