Suppress pause and buffer for local resources

content/renderer/media/buffered_data_source_unittest.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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/common/url_constants.h"
 #include "content/renderer/media/buffered_data_source.h"
 #include "content/renderer/media/test_response_generator.h"
 #include "content/test/mock_webframeclient.h"
@@ skipping 201 matching lines @@
   }
 
   Preload preload() { return data_source_->preload_; }
   BufferedResourceLoader::DeferStrategy defer_strategy() {
     return loader()->defer_strategy_;
   }
   int data_source_bitrate() { return data_source_->bitrate_; }
   int data_source_playback_rate() { return data_source_->playback_rate_; }
   int loader_bitrate() { return loader()->bitrate_; }
   int loader_playback_rate() { return loader()->playback_rate_; }
+  bool is_local_source() { return data_source_->assume_fully_buffered_; }
+  void set_might_be_reused_from_cache_in_future(bool value) {

[scherkus (not reviewing), 2014/06/02 20:02:33]

instead of setting this private variable it'd be preferable to create the proper
conditions to get it set in the first place by using response_generator_ to
respond with claiming range isn't supported

I believe Generate200() will do the right thing for you

[amogh.bihani, 2014/06/03 10:15:43]

Ummm... We want to have 'range_supported_' to be true and
'might_be_used_in_the_future_' also to be true. The latter is set false by
GetReasonsForUncashability[1].
We can set this to true by creating a new response like Generate206WithValidator
to dodge the if statement[2] and get reason == 0.
Otherwise we won't be able to test for kNeverDefer as BufferedResourceLoader
would convert it to kCapacityDefer[3].

So should we create a new repsonse - Generate206WithValidator()?
-----
[1]
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

[2]
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

[3]
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

+    loader()->might_be_reused_from_cache_in_future_ = value;
+  }
 
   scoped_ptr<MockBufferedDataSource> data_source_;
 
   scoped_ptr<TestResponseGenerator> response_generator_;
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   StrictMock<MockBufferedDataSourceHost> host_;
   base::MessageLoop message_loop_;
@@ skipping 430 matching lines @@
 TEST_F(BufferedDataSourceTest, File_FinishLoading) {
   InitializeWithFileResponse();
 
   EXPECT_FALSE(data_source_->downloading());
   FinishLoading();
   EXPECT_FALSE(data_source_->downloading());
 
   Stop();
 }
 
+TEST_F(BufferedDataSourceTest, LocalResource_DeferStrategy) {
+  InitializeWithFileResponse();
+
+  EXPECT_TRUE(is_local_source());
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());

[scherkus (not reviewing), 2014/06/02 20:02:33]

I believe this only tests the initial value and not the conditions under which
it could get changed:
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

we should basically have a few tests:
1) Initialize with file response, test initial value, test after playing, test
after pausing
2) Initialize with 200 response, test initial value, test after playing, test
after pausing
3) Initialize with 206 response, test initial value, test after playing, test
after pausing
4) Initialize with preload == metadata, test initial value == kReadThenDefer

[amogh.bihani, 2014/06/03 10:15:43]

Done.

+
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest, ExternalResource_PauseAndBufferDeferStrategy) {
+  InitializeWith206Response();
+
+  EXPECT_FALSE(is_local_source());
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  // Test for pause-and-buffer.
+  // When the playback has started and the media player is paused, the browser
+  // tries to load as much data as possible till it feels that the cashed data
+  // won't be useful in the future (Then it falls back to kCapacityDefer).
+  data_source_->MediaIsPlaying();
+  set_might_be_reused_from_cache_in_future(true);
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  set_might_be_reused_from_cache_in_future(false);
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
 }  // namespace content