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

media/cdm/ppapi/cdm_helpers.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_HELPERS_H_
 #define MEDIA_CDM_PPAPI_CDM_HELPERS_H_
 
 #include <map>
 #include <utility>
 
@@ skipping 19 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;
 
-  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);
 };
 
 class DecryptedBlockImpl : public cdm::DecryptedBlock {
@@ skipping 30 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);
 };
 
 class AudioFramesImpl : public cdm::AudioFrames_1,
                         public cdm::AudioFrames_2 {
  public:
@@ skipping 26 matching lines @@
  private:
   PpbBuffer* buffer_;
   cdm::AudioFormat format_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioFramesImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_CDM_PPAPI_CDM_HELPERS_H_