Add support for cancellation of demuxer reads.

media/base/pipeline_impl.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/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 293 matching lines @@
   base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
 
   SetState(kSeeking);
   renderer_ended_ = false;
   text_renderer_ended_ = false;
 
   // Queue asynchronous actions required to start.
   DCHECK(!pending_callbacks_);
   SerialRunner::Queue bound_fns;
 
+  // Abort any reads the renderer may be blocked on.
+  demuxer_->AbortPendingReads();

[wolenetz, 2016/08/25 18:56:14]

Would this be better integrated with how the MSE path needs the abort already
via PipelineController::Dispatch()'s calls to StartWaitingForSeek() and
CancelPendingSeek() (with appropriate implementation in FFmpegDemuxer of these
two methods to do the necessary abort tracking)?

This would let rapid sequential FFmpeg seeks cancel a previous incomplete seek
to satisfy a more recent one, just like in MSE case.

Perhaps this optimization could be done in a follow-up CL.

[DaleCurtis, 2016/08/29 21:14:58]

Good point. I think we just need to add AbortPendingReads() to
CancelPendingSeek() -- which is what I've done.

[wolenetz, 2016/08/30 18:52:12]

Acknowledged.

+
   // Pause.
   if (text_renderer_) {
     bound_fns.Push(base::Bind(&TextRenderer::Pause,
                               base::Unretained(text_renderer_.get())));
   }
 
   // Flush.
   DCHECK(shared_state_.renderer);
   bound_fns.Push(base::Bind(&Renderer::Flush,
                             base::Unretained(shared_state_.renderer.get())));
@@ skipping 21 matching lines @@
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive suspend in unexpected state: " << state_;
     OnPipelineError(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
   DCHECK(shared_state_.renderer);
   DCHECK(!pending_callbacks_.get());
 
   SetState(kSuspending);
 
-  // Freeze playback and record the media time before flushing. (Flushing clears
-  // the value.)
+  // Freeze playback and record the media time before destroying the renderer.
   shared_state_.renderer->SetPlaybackRate(0.0);
   {
     base::AutoLock auto_lock(shared_state_lock_);
     shared_state_.suspend_timestamp = shared_state_.renderer->GetMediaTime();
     DCHECK(shared_state_.suspend_timestamp != kNoTimestamp);
   }
 
+  // Abort any reads the renderer may be blocked on.
+  demuxer_->AbortPendingReads();
+
   // Queue the asynchronous actions required to stop playback.
   SerialRunner::Queue fns;
 
   if (text_renderer_) {
     fns.Push(base::Bind(&TextRenderer::Pause,
                         base::Unretained(text_renderer_.get())));
   }
 
-  fns.Push(base::Bind(&Renderer::Flush,
-                      base::Unretained(shared_state_.renderer.get())));
-
-  if (text_renderer_) {
-    fns.Push(base::Bind(&TextRenderer::Flush,
-                        base::Unretained(text_renderer_.get())));
-  }
-
+  // No need to flush the renderer since it's going to be destroyed.
   pending_callbacks_ = SerialRunner::Run(
       fns, base::Bind(&RendererWrapper::CompleteSuspend, weak_this_));
 }
 
 void PipelineImpl::RendererWrapper::Resume(std::unique_ptr<Renderer> renderer,
                                            base::TimeDelta timestamp) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Suppress resuming if we're not suspended.
   if (state_ != kSuspended) {
@@ skipping 845 matching lines @@
 void PipelineImpl::OnSuspendDone() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media