Add StreamParserBuffer to ChunkDemuxer

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"
-#include "media/base/data_buffer.h"
+#include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/chunk_demuxer_client.h"
 #include "media/webm/webm_stream_parser.h"
 
 namespace media {
 
 // TODO(acolwell): Remove this when fixing http://crbug.com/122909 .
 const char* kDefaultSourceType = "video/webm; codecs=\"vp8, vorbis\"";
 
-// Create an "end of stream" buffer.
-static Buffer* CreateEOSBuffer() {
-  return new DataBuffer(0);
-}
-
 class ChunkDemuxerStream : public DemuxerStream {
  public:
-  typedef std::deque<scoped_refptr<Buffer> > BufferQueue;
+  typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
   typedef std::deque<ReadCB> ReadCBQueue;
   typedef std::deque<base::Closure> ClosureQueue;
 
   explicit ChunkDemuxerStream(const AudioDecoderConfig& audio_config);
   explicit ChunkDemuxerStream(const VideoDecoderConfig& video_config);
   virtual ~ChunkDemuxerStream();
 
   void Flush();
   void Seek(base::TimeDelta time);
 
@@ skipping 159 matching lines @@
     base::AutoLock auto_lock(lock_);
     ChangeState_Locked(SHUTDOWN);
 
     std::swap(read_cbs_, read_cbs);
     buffers_.clear();
   }
 
   // Pass end of stream buffers to all callbacks to signal that no more data
   // will be sent.
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
-    it->Run(CreateEOSBuffer());
+    it->Run(StreamParserBuffer::CreateEOSBuffer());
 }
 
 bool ChunkDemuxerStream::GetLastBufferTimestamp(
     base::TimeDelta* timestamp) const {
   base::AutoLock auto_lock(lock_);
 
   if (buffers_.empty())
     return false;
 
   *timestamp = buffers_.back()->GetTimestamp();
@@ skipping 38 matching lines @@
         // Null buffers should be returned in this state since we are waiting
         // for a seek. Any buffers in |buffers_| should NOT be returned because
         // they are associated with the seek.
         DCHECK(read_cbs_.empty());
         break;
       case RECEIVED_EOS:
         DCHECK(read_cbs_.empty());
 
         if (buffers_.empty()) {
           ChangeState_Locked(RETURNING_EOS_FOR_READS);
-          buffer = CreateEOSBuffer();
+          buffer = StreamParserBuffer::CreateEOSBuffer();
         } else {
           buffer = buffers_.front();
           buffers_.pop_front();
         }
         break;
 
       case RETURNING_EOS_FOR_READS:
       case SHUTDOWN:
         DCHECK(buffers_.empty());
         DCHECK(read_cbs_.empty());
-        buffer = CreateEOSBuffer();
+        buffer = StreamParserBuffer::CreateEOSBuffer();
     }
   }
 
   read_cb.Run(buffer);
 }
 
 DemuxerStream::Type ChunkDemuxerStream::type() { return type_; }
 
 void ChunkDemuxerStream::EnableBitstreamConverter() {}
 
@@ skipping 29 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 = CreateEOSBuffer();
+  scoped_refptr<Buffer> 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)
     : state_(WAITING_FOR_INIT),
@@ skipping 245 matching lines @@
 
   ChangeState_Locked(ENDED);
 
   if (status != PIPELINE_OK) {
     ReportError_Locked(status);
     return;
   }
 
   // Create an end of stream buffer.
   ChunkDemuxerStream::BufferQueue buffers;
-  buffers.push_back(CreateEOSBuffer());
+  buffers.push_back(StreamParserBuffer::CreateEOSBuffer());
 
   if (audio_.get())
     audio_->AddBuffers(buffers);
 
   if (video_.get())
     video_->AddBuffers(buffers);
 }
 
 bool ChunkDemuxer::HasEnded() {
   base::AutoLock auto_lock(lock_);
@@ skipping 133 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