Suppress pause and buffer for local resources

content/renderer/media/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 "content/renderer/media/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/public/common/url_constants.h"
@@ skipping 183 matching lines @@
   if (playback_rate < 0.0f)
     return;
 
   playback_rate_ = playback_rate;
   loader_->SetPlaybackRate(playback_rate);
 }
 
 void BufferedDataSource::MediaIsPlaying() {
   DCHECK(render_loop_->BelongsToCurrentThread());
   media_has_played_ = true;
-  UpdateDeferStrategy(false);
+  // is_local_resource does not matter while playing, so send false.
+  UpdateDeferStrategy(false, false);
 }
 
-void BufferedDataSource::MediaIsPaused() {
+void BufferedDataSource::MediaIsPaused(bool is_local_resource) {
   DCHECK(render_loop_->BelongsToCurrentThread());
-  UpdateDeferStrategy(true);
+  UpdateDeferStrategy(true, is_local_resource);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // media::DataSource implementation.
 void BufferedDataSource::Stop(const base::Closure& closure) {
   {
     base::AutoLock auto_lock(lock_);
     StopInternal_Locked();
   }
   closure.Run();
@@ skipping 286 matching lines @@
 
   // 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);
 }
 
-void BufferedDataSource::UpdateDeferStrategy(bool paused) {
+void BufferedDataSource::UpdateDeferStrategy(bool paused,
+                                             bool is_local_resource) {
   // 200 responses end up not being reused to satisfy future range requests,
   // and we don't want to get too far ahead of the read-head (and thus require
   // a restart), so keep to the thresholds.
   if (!loader_->range_supported()) {
     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).
+  // useful from the cache in the future) for external resources. Loading data
+  // in buffer is not necessary while the player is paused.

[AmoghBihani, 2014/05/27 14:17:30]

Oh I am sorry, I will change this statement to "Loading data for local sources
is not necessary while player is paused." in the next patch set

   if (media_has_played_ && paused) {
+    if (is_local_resource) {
+      loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
+      return;
+    }
     loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
     return;
   }
 
   // If media is currently playing or the page indicated preload=auto,
   // use threshold strategy to enable/disable deferring when the buffer
   // is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
 }  // namespace content