Convert CreateCdmBuffer() to use size_t for |capacity|

media/mojo/services/mojo_cdm_allocator.cc

 // Copyright 2016 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/mojo/services/mojo_cdm_allocator.h"
 
+#include <limits>
+
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/numerics/safe_math.h"
 #include "media/cdm/api/content_decryption_module.h"
 #include "media/cdm/cdm_helpers.h"
 #include "media/cdm/simple_cdm_buffer.h"
 #include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "mojo/public/cpp/system/buffer.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace media {
 
 namespace {
 
 typedef base::Callback<void(mojo::ScopedSharedBufferHandle buffer,
-                            uint32_t capacity)>
+                            size_t capacity)>
     MojoSharedBufferDoneCB;
 
 VideoPixelFormat CdmVideoFormatToVideoPixelFormat(cdm::VideoFormat format) {
   switch (format) {
     case cdm::kYv12:
       return PIXEL_FORMAT_YV12;
     case cdm::kI420:
       return PIXEL_FORMAT_I420;
     default:
       NOTREACHED();
       return PIXEL_FORMAT_UNKNOWN;
   }
 }
 
 // cdm::Buffer implementation that provides access to mojo shared memory.
 // It owns the memory until Destroy() is called.
 class MojoCdmBuffer : public cdm::Buffer {
  public:
   static MojoCdmBuffer* Create(
       mojo::ScopedSharedBufferHandle buffer,
-      uint32_t capacity,
+      size_t capacity,
       const MojoSharedBufferDoneCB& mojo_shared_buffer_done_cb) {
     DCHECK(buffer.is_valid());
     DCHECK(!mojo_shared_buffer_done_cb.is_null());
-    return new MojoCdmBuffer(std::move(buffer), capacity,
+
+    // cdm::Buffer interface limits capacity to uint32.
+    DCHECK_LE(capacity,
+              static_cast<size_t>(std::numeric_limits<uint32_t>::max()));
+    return new MojoCdmBuffer(std::move(buffer),
+                             base::checked_cast<uint32_t>(capacity),
                              mojo_shared_buffer_done_cb);
   }
 
   // cdm::Buffer implementation.
   void Destroy() final {
     // Unmap the memory before returning the handle to |allocator_|.
     MojoResult result = mojo::UnmapBuffer(memory_);
     ALLOW_UNUSED_LOCAL(result);
     DCHECK(result == MOJO_RESULT_OK);
     memory_ = nullptr;
@@ skipping 100 matching lines @@
 
 }  // namespace
 
 MojoCdmAllocator::MojoCdmAllocator() : weak_ptr_factory_(this) {}
 
 MojoCdmAllocator::~MojoCdmAllocator() {}
 
 // Creates a cdm::Buffer, reusing an existing buffer if one is available.
 // If not, a new buffer is created using AllocateNewBuffer(). The caller is
 // responsible for calling Destroy() on the buffer when it is no longer needed.
-cdm::Buffer* MojoCdmAllocator::CreateCdmBuffer(uint32_t capacity) {
+cdm::Buffer* MojoCdmAllocator::CreateCdmBuffer(size_t capacity) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!capacity)
     return nullptr;
 
   // Reuse a buffer in the free map if there is one that fits |capacity|.
   // Otherwise, create a new one.
   mojo::ScopedSharedBufferHandle buffer;
   auto found = available_buffers_.lower_bound(capacity);
   if (found == available_buffers_.end()) {
@@ skipping 17 matching lines @@
 
 // Creates a new SimpleCdmVideoFrame on every request.
 scoped_ptr<VideoFrameImpl> MojoCdmAllocator::CreateCdmVideoFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return make_scoped_ptr(new MojoCdmVideoFrame(
       base::Bind(&MojoCdmAllocator::AddBufferToAvailableMap,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
 mojo::ScopedSharedBufferHandle MojoCdmAllocator::AllocateNewBuffer(
-    uint32_t* capacity) {
+    size_t* capacity) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Always pad new allocated buffer so that we don't need to reallocate
   // buffers frequently if requested sizes fluctuate slightly.
-  static const uint32_t kBufferPadding = 512;
+  static const size_t kBufferPadding = 512;
 
   // Maximum number of free buffers we can keep when allocating new buffers.
-  static const uint32_t kFreeLimit = 3;
+  static const size_t kFreeLimit = 3;
 
   // 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 (available_buffers_.size() >= kFreeLimit)
     available_buffers_.erase(available_buffers_.begin());
 
   // Creation of shared memory may be expensive if it involves synchronous IPC
   // calls. That's why we try to avoid AllocateNewBuffer() as much as we can.
   mojo::ScopedSharedBufferHandle handle;
-  base::CheckedNumeric<uint32_t> requested_capacity(*capacity);
+  base::CheckedNumeric<size_t> requested_capacity(*capacity);
   requested_capacity += kBufferPadding;
   MojoResult result = mojo::CreateSharedBuffer(
       nullptr, requested_capacity.ValueOrDie(), &handle);
   if (result != MOJO_RESULT_OK)
     return mojo::ScopedSharedBufferHandle();
   DCHECK(handle.is_valid());
   *capacity = requested_capacity.ValueOrDie();
   return handle;
 }
 
 void MojoCdmAllocator::AddBufferToAvailableMap(
     mojo::ScopedSharedBufferHandle buffer,
-    uint32_t capacity) {
+    size_t capacity) {
   DCHECK(thread_checker_.CalledOnValidThread());
   available_buffers_.insert(std::make_pair(capacity, std::move(buffer)));
 }
 
 MojoHandle MojoCdmAllocator::GetHandleForTesting(cdm::Buffer* buffer) {
   MojoCdmBuffer* mojo_buffer = static_cast<MojoCdmBuffer*>(buffer);
   return mojo_buffer->Handle().value();
 }
 
 size_t MojoCdmAllocator::GetAvailableBufferCountForTesting() {
   return available_buffers_.size();
 }
 
 }  // namespace media