Remove buffer duration calculation from WebMClusterParser and update SourceBufferStream accordingly

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 "base/string_util.h"
@@ skipping 139 matching lines @@
   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);
 
   void StartWaitingForSeek();
   void Seek(TimeDelta time);
   bool IsSeekPending() const;
-  void Flush();
 
   // Add buffers to this stream.  Buffers are stored in SourceBufferStreams,
   // which handle ordering and overlap resolution.
   // Returns true if buffers were successfully added.
   bool Append(const StreamParser::BufferQueue& buffers);
 
   // Signal to the stream that buffers handed in through subsequent calls to
   // Append() belong to a media segment that starts at |start_timestamp|.
   void OnNewMediaSegment(TimeDelta start_timestamp);
 
@@ skipping 38 matching lines @@
 
   // Specifies the type of the stream (must be AUDIO or VIDEO for now).
   Type type_;
 
   scoped_ptr<SourceBufferStream> stream_;
 
   mutable base::Lock lock_;
   State state_;
   ReadCBQueue read_cbs_;
 
-  // The timestamp of the current media segment being parsed by
-  // |stream_parser_|.
-  TimeDelta media_segment_start_time_;
-
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 ChunkDemuxerStream::ChunkDemuxerStream(const AudioDecoderConfig& audio_config)
     : type_(AUDIO),
-      state_(RETURNING_DATA_FOR_READS),
-      media_segment_start_time_(kNoTimestamp()) {
+      state_(RETURNING_DATA_FOR_READS) {
   stream_.reset(new SourceBufferStream(audio_config));
 }
 
 ChunkDemuxerStream::ChunkDemuxerStream(const VideoDecoderConfig& video_config)
     : type_(VIDEO),
       state_(RETURNING_DATA_FOR_READS) {
   stream_.reset(new SourceBufferStream(video_config));
 }
 
 void ChunkDemuxerStream::StartWaitingForSeek() {
@@ skipping 19 matching lines @@
 
   if (state_ == WAITING_FOR_SEEK)
     ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
 bool ChunkDemuxerStream::IsSeekPending() const {
   base::AutoLock auto_lock(lock_);
   return stream_->IsSeekPending();
 }
 
-void ChunkDemuxerStream::Flush() {
-  media_segment_start_time_ = kNoTimestamp();
-}
-
 void ChunkDemuxerStream::OnNewMediaSegment(TimeDelta start_timestamp) {
-  media_segment_start_time_ = start_timestamp;
+  base::AutoLock auto_lock(lock_);
+  stream_->OnNewMediaSegment(start_timestamp);
 }
 
 bool ChunkDemuxerStream::Append(const StreamParser::BufferQueue& buffers) {
   if (buffers.empty())
     return false;
 
   ClosureQueue closures;
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_NE(state_, SHUTDOWN);
-    DCHECK(media_segment_start_time_ != kNoTimestamp());
-    if (!stream_->Append(buffers, media_segment_start_time_)) {
+    if (!stream_->Append(buffers)) {
       DVLOG(1) << "ChunkDemuxerStream::Append() : stream append failed";
       return false;
     }
     CreateReadDoneClosures_Locked(&closures);
   }
 
   for (ClosureQueue::iterator it = closures.begin(); it != closures.end(); ++it)
     it->Run();
 
   return true;
@@ skipping 455 matching lines @@
 
   return true;
 }
 
 void ChunkDemuxer::Abort(const std::string& id) {
   DVLOG(1) << "Abort(" << id << ")";
   DCHECK(!id.empty());
   DCHECK_GT(stream_parser_map_.count(id), 0u);
 
   stream_parser_map_[id]->Flush();
-  if (audio_ && source_id_audio_ == id)
-    audio_->Flush();
-  if (video_ && source_id_video_ == id)
-    video_->Flush();
 }
 
 bool ChunkDemuxer::EndOfStream(PipelineStatus status) {
   DVLOG(1) << "EndOfStream(" << status << ")";
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, WAITING_FOR_INIT);
   DCHECK_NE(state_, ENDED);
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return true;
@@ skipping 218 matching lines @@
   // TODO(vrk): There should be a special case for the first appends where all
   // streams (for both demuxed and muxed case) begin at the earliest stream
   // timestamp. (crbug.com/132815)
   if (audio_ && source_id == source_id_audio_)
     audio_->OnNewMediaSegment(start_timestamp);
   if (video_ && source_id == source_id_video_)
     video_->OnNewMediaSegment(start_timestamp);
 }
 
 }  // namespace media