Add support for cancellation of demuxer reads.

media/blink/multibuffer_data_source.cc

 // Copyright 2013 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/blink/multibuffer_data_source.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 246 matching lines @@
   if (cors_mode_ == UrlData::CORS_UNSPECIFIED)
     return false;
   // If init_cb is set, we initialization is not finished yet.
   if (!init_cb_.is_null())
     return false;
   if (failed_)
     return false;
   return true;
 }
 
-void MultibufferDataSource::Abort() {
-  DCHECK(render_task_runner_->BelongsToCurrentThread());
-  {
-    base::AutoLock auto_lock(lock_);
-    StopInternal_Locked();
-  }
-  StopLoader();
-  frame_ = NULL;
-}
-
 void MultibufferDataSource::MediaPlaybackRateChanged(double playback_rate) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   DCHECK(reader_.get());
 
   if (playback_rate < 0.0)
     return;
 
   playback_rate_ = playback_rate;
   cancel_on_defer_ = false;
   UpdateBufferSizes();
@@ skipping 14 matching lines @@
   {
     base::AutoLock auto_lock(lock_);
     StopInternal_Locked();
   }
 
   render_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&MultibufferDataSource::StopLoader,
                                            weak_factory_.GetWeakPtr()));
 }
 
+void MultibufferDataSource::Abort() {
+  base::AutoLock auto_lock(lock_);
+  DCHECK(init_cb_.is_null());
+  if (read_op_)
+    ReadOperation::Run(std::move(read_op_), kAborted);
+
+  // Abort does not call StopLoader() since it is typically called prior to a
+  // seek or suspend. Let the loader logic make the decision about whether a new
+  // loader is necessary upon the seek or resume.
+}
+
 void MultibufferDataSource::SetBitrate(int bitrate) {
   render_task_runner_->PostTask(
       FROM_HERE, base::Bind(&MultibufferDataSource::SetBitrateTask,
                             weak_factory_.GetWeakPtr(), bitrate));
 }
 
 void MultibufferDataSource::OnBufferingHaveEnough(bool always_cancel) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   if (reader_ && (always_cancel || (preload_ == METADATA &&
                                     !media_has_played_ && !IsStreaming()))) {
@@ skipping 53 matching lines @@
   return streaming_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // This method is the place where actual read happens,
 void MultibufferDataSource::ReadTask() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   int bytes_read = 0;
-  if (stop_signal_received_)
+  if (stop_signal_received_ || !read_op_)
     return;
-  DCHECK(read_op_);
   DCHECK(read_op_->size());
 
   if (!reader_) {
     CreateResourceLoader(read_op_->position(), kPositionNotSpecified);
   } else {
     reader_->Seek(read_op_->position());
   }
 
   int64_t available = reader_->Available();
   if (available < 0) {
@@ skipping 200 matching lines @@
   reader_->SetPinRange(back_buffer, kMaxBufferPreload + kPreloadHighExtra);
 
   if (preload_ == METADATA) {
     reader_->SetPreload(0, 0);
   } else {
     reader_->SetPreload(preload_high, preload);
   }
 }
 
 }  // namespace media