Introducing DecoderBuffer and general Buffer cleanup.

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 198 matching lines @@
   {
     base::AutoLock auto_lock(lock_);
     buffers_.clear();
     ChangeState_Locked(WAITING_FOR_SEEK);
     last_buffer_timestamp_ = kNoTimestamp();
 
     std::swap(read_cbs_, read_cbs);
   }
 
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
-    it->Run(scoped_refptr<Buffer>());
+    it->Run(scoped_refptr<DecoderBuffer>());
 }
 
 void ChunkDemuxerStream::Seek(base::TimeDelta time) {
   base::AutoLock auto_lock(lock_);
 
   DCHECK(read_cbs_.empty());
 
   if (state_ == WAITING_FOR_SEEK) {
     ChangeState_Locked(RETURNING_DATA_FOR_READS);
     return;
@@ skipping 88 matching lines @@
   base::TimeDelta end_duration = buffers_.back()->GetDuration();
   if (end_duration != kNoTimestamp())
     *end_out += end_duration;
 
   return true;
 }
 
 // Helper function that makes sure |read_cb| runs on |message_loop|.
 static void RunOnMessageLoop(const DemuxerStream::ReadCB& read_cb,
                              MessageLoop* message_loop,
-                             const scoped_refptr<Buffer>& buffer) {
+                             const scoped_refptr<DecoderBuffer>& buffer) {
   if (MessageLoop::current() != message_loop) {
     message_loop->PostTask(FROM_HERE, base::Bind(
         &RunOnMessageLoop, read_cb, message_loop, buffer));
     return;
   }
 
   read_cb.Run(buffer);
 }
 
 // DemuxerStream methods.
 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
-  scoped_refptr<Buffer> buffer;
+  scoped_refptr<DecoderBuffer> buffer;
 
   {
     base::AutoLock auto_lock(lock_);
 
     switch (state_) {
       case RETURNING_DATA_FOR_READS:
         // If we don't have any buffers ready or already have
         // pending reads, then defer this read.
         if (buffers_.empty() || !read_cbs_.empty()) {
           DeferRead_Locked(read_cb);
@@ skipping 72 matching lines @@
   while (!buffers_.empty() && !read_cbs_.empty()) {
     closures->push_back(base::Bind(read_cbs_.front(), buffers_.front()));
     buffers_.pop_front();
     read_cbs_.pop_front();
   }
 
   if (state_ != RECEIVED_EOS || !buffers_.empty() || read_cbs_.empty())
     return;
 
   // Push enough EOS buffers to satisfy outstanding Read() requests.
-  scoped_refptr<Buffer> end_of_stream_buffer =
+  scoped_refptr<DecoderBuffer> end_of_stream_buffer =
       StreamParserBuffer::CreateEOSBuffer();
   while (!read_cbs_.empty()) {
     closures->push_back(base::Bind(read_cbs_.front(), end_of_stream_buffer));
     read_cbs_.pop_front();
   }
 
   ChangeState_Locked(RETURNING_EOS_FOR_READS);
 }
 
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
@@ skipping 447 matching lines @@
   return true;
 }
 
 bool ChunkDemuxer::OnKeyNeeded(scoped_array<uint8> init_data,
                                int init_data_size) {
   client_->KeyNeeded(init_data.Pass(), init_data_size);
   return true;
 }
 
 }  // namespace media