Cancel pending seek in ChunkDemuxer when a new seek occurs

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 <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 155 matching lines @@
  public:
   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);
+  void CancelPendingSeek();
   bool IsSeekPending() const;
 
   // 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);
 
   // Returns the range of buffered data in this stream, capped at |duration|.
   Ranges<TimeDelta> GetBufferedRanges(base::TimeDelta duration) const;
 
@@ skipping 21 matching lines @@
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
 
  protected:
   virtual ~ChunkDemuxerStream();
 
  private:
   enum State {
     RETURNING_DATA_FOR_READS,
     WAITING_FOR_SEEK,
+    CANCELED,
     SHUTDOWN,
   };
 
   // Assigns |state_| to |state|
   void ChangeState_Locked(State state);
 
   // Adds the callback to |read_cbs_| so it can be called later when we
   // have data.
   void DeferRead_Locked(const ReadCB& read_cb);
 
@@ skipping 46 matching lines @@
 
   for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
     it->Run(kAborted, NULL);
 }
 
 void ChunkDemuxerStream::Seek(TimeDelta time) {
   base::AutoLock auto_lock(lock_);
 
   DCHECK(read_cbs_.empty());
 
+  // Ignore seek requests when cancelled.

[acolwell GONE FROM CHROMIUM, 2012/08/07 23:36:11]

s/cancelled/canceled/

[vrk (LEFT CHROMIUM), 2012/08/08 00:01:21]

Done.

+  if (state_ == CANCELED)
+    return;
+
   stream_->Seek(time);
 
   if (state_ == WAITING_FOR_SEEK)
     ChangeState_Locked(RETURNING_DATA_FOR_READS);
 }
 
+void ChunkDemuxerStream::CancelPendingSeek() {
+  DVLOG(1) << "CancelPendingSeek()";
+  ReadCBQueue read_cbs;
+  {
+    base::AutoLock auto_lock(lock_);
+    ChangeState_Locked(CANCELED);
+    std::swap(read_cbs_, read_cbs);
+  }
+
+  for (ReadCBQueue::iterator it = read_cbs.begin(); it != read_cbs.end(); ++it)
+    it->Run(kAborted, NULL);
+}
+
 bool ChunkDemuxerStream::IsSeekPending() const {
   base::AutoLock auto_lock(lock_);
   return stream_->IsSeekPending();
 }
 
 void ChunkDemuxerStream::OnNewMediaSegment(TimeDelta start_timestamp) {
   base::AutoLock auto_lock(lock_);
   DCHECK(!end_of_stream_);
   stream_->OnNewMediaSegment(start_timestamp);
 }
@@ skipping 184 matching lines @@
             *buffer = StreamParserBuffer::CreateEOSBuffer();
             return true;
           }
           return false;
         case SourceBufferStream::kConfigChange:
           *status = kConfigChanged;
           *buffer = NULL;
           return true;
       }
       break;
+    case CANCELED:
     case WAITING_FOR_SEEK:
       // Null buffers should be returned in this state since we are waiting
       // for a seek. Any buffers in the SourceBuffer should NOT be returned
       // because they are associated with the seek.
       DCHECK(read_cbs_.empty());
       *status = DemuxerStream::kAborted;
       *buffer = NULL;
       return true;
     case SHUTDOWN:
       DCHECK(read_cbs_.empty());
@@ skipping 30 matching lines @@
 
 void ChunkDemuxer::Stop(const base::Closure& callback) {
   DVLOG(1) << "Stop()";
   Shutdown();
   callback.Run();
 }
 
 void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
   DVLOG(1) << "Seek(" << time.InSecondsF() << ")";
   DCHECK(time >= start_time_);
+  DCHECK(seek_cb_.is_null());
 
   PipelineStatus status = PIPELINE_ERROR_INVALID_STATE;
   {
     base::AutoLock auto_lock(lock_);
 
     if (state_ == INITIALIZED || state_ == ENDED) {
       if (audio_)
         audio_->Seek(time);
 
       if (video_)
@@ skipping 45 matching lines @@
 
   if (audio_)
     audio_->StartWaitingForSeek();
 
   if (video_)
     video_->StartWaitingForSeek();
 
   ChangeState_Locked(INITIALIZED);
 }
 
+void ChunkDemuxer::CancelPendingSeek() {
+  PipelineStatusCB cb;
+  {
+    base::AutoLock auto_lock(lock_);
+    if (IsSeekPending_Locked() && !seek_cb_.is_null()) {
+      std::swap(cb, seek_cb_);
+    }
+  }
+
+  if (audio_)
+    audio_->CancelPendingSeek();

[acolwell GONE FROM CHROMIUM, 2012/08/07 23:36:11]

I think these should to be inside the locked section.

[vrk (LEFT CHROMIUM), 2012/08/08 00:01:21]

Oops, yes! Just the callback should be run outside of the lock.

+
+  if (video_)
+    video_->CancelPendingSeek();
+
+  if (!cb.is_null())
+    cb.Run(PIPELINE_OK);
+}
+
 ChunkDemuxer::Status ChunkDemuxer::AddId(const std::string& id,
                                          const std::string& type,
                                          std::vector<std::string>& codecs) {
   DCHECK_GT(codecs.size(), 0u);
   base::AutoLock auto_lock(lock_);
 
   if (state_ != WAITING_FOR_INIT && state_ != INITIALIZING)
     return kReachedIdLimit;
 
   bool has_audio = false;
@@ skipping 532 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media