Enhance WebMediaPlayer::buffered() to account for evicted ranges.

media/blink/buffered_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/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/media_log.h"
@@ skipping 475 matching lines @@
     // we should consider changing DownloadingCB to also propagate loading
     // state. For example there isn't any signal today to notify the client that
     // loading has failed (we only get errors on subsequent reads).
     case BufferedResourceLoader::kLoadingFailed:
       return;
   }
 
   downloading_cb_.Run(is_downloading_data);
 }
 
-void BufferedDataSource::ProgressCallback(int64 position) {
+void BufferedDataSource::ProgressCallback(int64 earliest_position,
+                                          int64 position) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (assume_fully_buffered())
     return;
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
   base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   host_->AddBufferedByteRange(loader_->first_byte_position(), position);
+  host_->RemoveBufferedByteRange(earliest_position);
 }
 
 void BufferedDataSource::UpdateDeferStrategy(bool paused) {
   // No need to aggressively buffer when we are assuming the resource is fully
   // buffered.
   if (assume_fully_buffered()) {
     loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
     return;
   }
 
   // If the playback has started (at which point the preload value is ignored)
   // and we're paused, then try to load as much as possible (the loader will
   // fall back to kCapacityDefer if it knows the current response won't be
   // useful from the cache in the future).
   if (media_has_played_ && paused && loader_->range_supported()) {
     loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
     return;
   }
 
   // If media is currently playing or the page indicated preload=auto or the
   // the server does not support the byte range request or we do not want to go
   // too far ahead of the read head, use threshold strategy to enable/disable
   // deferring when the buffer is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
 }  // namespace media