Introduce CancelUponDeferral() to buffered media loaders.

media/blink/buffered_resource_loader.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/buffered_resource_loader.h"
 
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 106 matching lines @@
       offset_(0),
       content_length_(kPositionNotSpecified),
       instance_size_(kPositionNotSpecified),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       first_offset_(0),
       last_offset_(0),
       bitrate_(bitrate),
       playback_rate_(playback_rate),
-      media_log_(media_log) {
+      media_log_(media_log),
+      cancel_upon_deferral_(false) {
 
   // Set the initial capacity of |buffer_| based on |bitrate_| and
   // |playback_rate_|.
   UpdateBufferWindow();
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {}
 
 void BufferedResourceLoader::Start(
     const StartCB& start_cb,
@@ skipping 433 matching lines @@
 }
 
 void BufferedResourceLoader::SetPlaybackRate(float playback_rate) {
   playback_rate_ = playback_rate;
 
   // This is a pause so don't bother updating the buffer window as we'll likely
   // get unpaused in the future.
   if (playback_rate_ == 0.0)
     return;
 
+  // Abort any cancellations in progress if playback starts.
+  if (playback_rate_ > 0 && cancel_upon_deferral_)
+    cancel_upon_deferral_ = false;
+
   UpdateBufferWindow();
 }
 
 void BufferedResourceLoader::SetBitrate(int bitrate) {
   DCHECK(bitrate >= 0);
   bitrate_ = bitrate;
   UpdateBufferWindow();
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ skipping 18 matching lines @@
 
   SetDeferred(ShouldDefer());
 }
 
 void BufferedResourceLoader::SetDeferred(bool deferred) {
   if (active_loader_->deferred() == deferred)
     return;
 
   active_loader_->SetDeferred(deferred);
   loading_cb_.Run(deferred ? kLoadingDeferred : kLoading);
+
+  if (deferred && cancel_upon_deferral_)
+    CancelUponDeferral();
 }
 
 bool BufferedResourceLoader::ShouldDefer() const {
   switch(defer_strategy_) {
     case kNeverDefer:
       return false;
 
     case kReadThenDefer:
       DCHECK(read_cb_.is_null() || last_offset_ > buffer_.forward_bytes())
           << "We shouldn't stop deferring if we can fulfill the read";
@@ skipping 96 matching lines @@
   }
   if (*last_byte_position < *first_byte_position ||
       (*instance_size != kPositionNotSpecified &&
        *last_byte_position >= *instance_size)) {
     return false;
   }
 
   return true;
 }
 
+void BufferedResourceLoader::CancelUponDeferral() {
+  cancel_upon_deferral_ = true;
+  if (active_loader_ && active_loader_->deferred())
+    active_loader_.reset();
+}
+
 bool BufferedResourceLoader::VerifyPartialResponse(
     const WebURLResponse& response) {
   int64 first_byte_position, last_byte_position, instance_size;
   if (!ParseContentRange(response.httpHeaderField("Content-Range").utf8(),
                          &first_byte_position, &last_byte_position,
                          &instance_size)) {
     return false;
   }
 
   if (instance_size != kPositionNotSpecified) {
@@ skipping 36 matching lines @@
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
 }  // namespace media