Introducing DecoderBuffer and general Buffer cleanup.

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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/filters/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
+#include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/filter_host.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 
 namespace media {
 
 GpuVideoDecoder::Factories::~Factories() {}
 
 // Size of shared-memory segments we allocate.  Since we reuse them we let them
 // be on the beefy side.
 static const size_t kSharedMemorySegmentBytes = 100 << 10;
 
 GpuVideoDecoder::SHMBuffer::SHMBuffer(base::SharedMemory* m, size_t s)
     : shm(m), size(s) {
 }
 
 GpuVideoDecoder::SHMBuffer::~SHMBuffer() {}
 
 GpuVideoDecoder::BufferPair::BufferPair(
-    SHMBuffer* s, const scoped_refptr<Buffer>& b) : shm_buffer(s), buffer(b) {
+    SHMBuffer* s, const scoped_refptr<DecoderBuffer>& b)
+    : shm_buffer(s), buffer(b) {
 }
 
 GpuVideoDecoder::BufferPair::~BufferPair() {}
 
 GpuVideoDecoder::BufferTimeData::BufferTimeData(
     int32 bbid, base::TimeDelta ts, base::TimeDelta dur)
     : bitstream_buffer_id(bbid), timestamp(ts), duration(dur) {
 }
 
 GpuVideoDecoder::BufferTimeData::~BufferTimeData() {}
@@ skipping 143 matching lines @@
     case kNormal:
       EnsureDemuxOrDecode();
       break;
     case kDrainingDecoder:
       // Do nothing.  Will be satisfied either by a PictureReady or
       // NotifyFlushDone below.
       break;
   }
 }
 
-void GpuVideoDecoder::RequestBufferDecode(const scoped_refptr<Buffer>& buffer) {
+void GpuVideoDecoder::RequestBufferDecode(
+    const scoped_refptr<DecoderBuffer>& buffer) {
   if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::RequestBufferDecode, this, buffer));
     return;
   }
   demuxer_read_in_progress_ = false;
 
   if (!buffer) {
     if (pending_read_cb_.is_null())
       return;
@@ skipping 226 matching lines @@
 
   std::map<int32, BufferPair>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   PutSHM(it->second.shm_buffer);
-  const scoped_refptr<Buffer>& buffer = it->second.buffer;
+  const scoped_refptr<DecoderBuffer>& buffer = it->second.buffer;
   if (buffer->GetDataSize()) {
     PipelineStatistics statistics;
     statistics.video_bytes_decoded = buffer->GetDataSize();
     statistics_cb_.Run(statistics);
   }
   bitstream_buffers_in_decoder_.erase(it);
 
   if (!pending_read_cb_.is_null() && pending_reset_cb_.is_null() &&
       state_ != kDrainingDecoder &&
       bitstream_buffers_in_decoder_.empty()) {
@@ skipping 75 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media