Encrypted Media: Fix PpbBuffer::Destroy().

media/cdm/ppapi/cdm_helpers.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_helpers.h"
 
+#include <algorithm>

[xhwang, 2014/07/10 16:42:39]

This is for std::swap.

 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "build/build_config.h"
 #include "media/cdm/ppapi/api/content_decryption_module.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/dev/buffer_dev.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 
 namespace media {
 
+// static
+PpbBuffer* PpbBuffer::Create(const pp::Buffer_Dev& buffer,
+                             uint32_t buffer_id,
+                             PpbBufferAllocator* allocator) {
+  PP_DCHECK(buffer.data());
+  PP_DCHECK(buffer.size());
+  PP_DCHECK(buffer_id);
+  PP_DCHECK(allocator);
+  return new PpbBuffer(buffer, buffer_id, allocator);
+}
+
+void PpbBuffer::Destroy() {
+  delete this;
+}
+
+uint32_t PpbBuffer::Capacity() const {
+  return buffer_.size();
+}
+
+uint8_t* PpbBuffer::Data() {
+  return static_cast<uint8_t*>(buffer_.data());
+}
+
+void PpbBuffer::SetSize(uint32_t size) {
+  PP_DCHECK(size <= Capacity());
+  if (size > Capacity()) {
+    size_ = 0;
+    return;
+  }
+
+  size_ = size;
+}
+
+pp::Buffer_Dev PpbBuffer::TakeBufferDev() {
+  PP_DCHECK(!buffer_.is_null());
+  pp::Buffer_Dev buffer;
+  std::swap(buffer, buffer_);
+  buffer_id_ = 0;
+  size_ = 0;
+  return buffer;
+}
+
+PpbBuffer::PpbBuffer(pp::Buffer_Dev buffer,
+                     uint32_t buffer_id,
+                     PpbBufferAllocator* allocator)
+    : buffer_(buffer), buffer_id_(buffer_id), size_(0), allocator_(allocator) {
+}
+
+PpbBuffer::~PpbBuffer() {
+  // If still owning the |buffer_|, release it in the |allocator_|.
+  if (buffer_id_) {
+    PP_DCHECK(!buffer_.is_null());

[ddorwin, 2014/07/10 21:56:14]

nit: Move up and make sure !id == !is_null()

[xhwang, 2014/07/10 22:37:33]

Done.

+    allocator_->Release(buffer_id_);

[xhwang, 2014/07/10 16:42:39]

Sorry for moving things around. The changes in this class are:
1) Add allocator in ctor and in Create().
2) Call allocator_->Release() in dtor.
3) Change buffer_dev() to TakeBufferDev() to make ownership clearer.

+  }
+}
+
 cdm::Buffer* PpbBufferAllocator::Allocate(uint32_t capacity) {
   PP_DCHECK(pp::Module::Get()->core()->IsMainThread());
 
   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.
     buffer = AllocateNewBuffer(capacity);
     if (buffer.is_null())
       return NULL;
     buffer_id = next_buffer_id_++;
   } else {
     buffer = found->second.second;
     buffer_id = found->second.first;
     free_buffers_.erase(found);
   }
 
   allocated_buffers_.insert(std::make_pair(buffer_id, buffer));
 
-  return PpbBuffer::Create(buffer, buffer_id);
+  return PpbBuffer::Create(buffer, buffer_id, this);
 }
 
 void PpbBufferAllocator::Release(uint32_t buffer_id) {
   if (!buffer_id)
     return;
 
   AllocatedBufferMap::iterator found = allocated_buffers_.find(buffer_id);
   if (found == allocated_buffers_.end())
     return;
 
@@ skipping 33 matching lines @@
     strides_[i] = 0;
   }
 }
 
 VideoFrameImpl::~VideoFrameImpl() {
   if (frame_buffer_)
     frame_buffer_->Destroy();
 }
 
 }  // namespace media