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 103 matching lines @@
     view_->setMainFrame(frame_);
   }
 
   virtual ~BufferedDataSourceTest() {
     view_->close();
     frame_->close();
   }
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
-  void Initialize(const char* url, bool expected) {
+  void Initialize(const char* url, bool expected, Preload preload = AUTO) {

[scherkus (not reviewing), 2014/06/06 16:39:20]

instead of default arguments (which the style guide recommends against) use a
member variable and a setter on BufferedDataSourceTest

e.g., 

void set_preload(Preload preload) { preload_ = preload; }
Preload preload_;  // ctor sets it to AUTO

void Initialize(...) {
  data_source_->SetPreload(preload_);
}

that way only the tests that need to have it set to METADATA can call
set_preload(METADATA) prior to calling InitializeXXX()

     GURL gurl(url);
     data_source_.reset(
         new MockBufferedDataSource(gurl,
                                    message_loop_.message_loop_proxy(),
                                    view_->mainFrame()->toWebLocalFrame(),
                                    &host_));
+    data_source_->SetPreload(preload);
 
     response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
     ExpectCreateResourceLoader();
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->Initialize(base::Bind(&BufferedDataSourceTest::OnInitialize,
                                         base::Unretained(this)));
     message_loop_.RunUntilIdle();
 
     bool is_http = gurl.SchemeIsHTTPOrHTTPS();
     EXPECT_EQ(data_source_->downloading(), is_http);
   }
 
+  // Helper to initialize tests with a valid 200 response.
+  void InitializeWith200Response(Preload preload = AUTO) {
+    Initialize(kHttpUrl, true, preload);
+
+    EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
+    Respond(response_generator_->Generate200());
+  }
+
   // Helper to initialize tests with a valid 206 response.
-  void InitializeWith206Response() {
-    Initialize(kHttpUrl, true);
+  void InitializeWith206Response(Preload preload = AUTO) {
+    Initialize(kHttpUrl, true, preload);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate206(0));
   }
 
   // Helper to initialize tests with a valid file:// response.
-  void InitializeWithFileResponse() {
-    Initialize(kFileUrl, true);
+  void InitializeWithFileResponse(Preload preload = AUTO) {
+    Initialize(kFileUrl, true, preload);
 
     EXPECT_CALL(host_, SetTotalBytes(kFileSize));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kFileSize));
     Respond(response_generator_->GenerateFileResponse(0));
   }
 
   // Stops any active loaders and shuts down the data source.
   //
   // This typically happens when the page is closed and for our purposes is
   // appropriate to do when tearing down a test.
@@ skipping 51 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) {
+    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_;
 
  private:
   // Used for calling BufferedDataSource::Read().
   uint8 buffer_[kDataSize];
 
   DISALLOW_COPY_AND_ASSIGN(BufferedDataSourceTest);
 };
 
 TEST_F(BufferedDataSourceTest, Range_Supported) {
-  Initialize(kHttpUrl, true);
-
-  EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
-  Respond(response_generator_->Generate206(0));
+  InitializeWith206Response();
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_FALSE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_InstanceSizeUnknown) {
   Initialize(kHttpUrl, true);
 
   Respond(response_generator_->Generate206(
       0, TestResponseGenerator::kNoContentRangeInstanceSize));
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_TRUE(data_source_->IsStreaming());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_NotFound) {
   Initialize(kHttpUrl, false);
   Respond(response_generator_->Generate404());
 
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
 TEST_F(BufferedDataSourceTest, Range_NotSupported) {
-  Initialize(kHttpUrl, true);
-  EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
-  Respond(response_generator_->Generate200());
+  InitializeWith200Response();
 
   EXPECT_TRUE(data_source_->loading());
   EXPECT_TRUE(data_source_->IsStreaming());
   Stop();
 }
 
 // Special carve-out for Apache versions that choose to return a 200 for
 // Range:0- ("because it's more efficient" than a 206)
 TEST_F(BufferedDataSourceTest, Range_SupportedButReturned200) {
   Initialize(kHttpUrl, true);
@@ skipping 378 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_EQ(AUTO, preload());
+  EXPECT_TRUE(is_local_source());
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest, LocalResource_PreloadMetadata_DeferStrategy) {
+  InitializeWithFileResponse(METADATA);
+
+  EXPECT_EQ(METADATA, preload());
+  EXPECT_TRUE(is_local_source());
+  EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest, ExternalResource_Reponse200_DeferStrategy) {
+  InitializeWith200Response();
+
+  EXPECT_EQ(AUTO, preload());
+  EXPECT_FALSE(is_local_source());
+  EXPECT_FALSE(loader()->range_supported());
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest,
+       ExternalResource_Response200_PreloadMetadata_DeferStrategy) {
+  InitializeWith200Response(METADATA);
+
+  EXPECT_EQ(METADATA, preload());
+  EXPECT_FALSE(is_local_source());
+  EXPECT_FALSE(loader()->range_supported());
+  EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest, ExternalResource_Reponse206_DeferStrategy) {
+  InitializeWith206Response();
+
+  EXPECT_EQ(AUTO, preload());
+  EXPECT_FALSE(is_local_source());
+  EXPECT_TRUE(loader()->range_supported());
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+  set_might_be_reused_from_cache_in_future(true);
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+  set_might_be_reused_from_cache_in_future(false);
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest,
+       ExternalResource_Response206_PreloadMetadata_DeferStrategy) {
+  InitializeWith206Response(METADATA);
+
+  EXPECT_EQ(METADATA, preload());
+  EXPECT_FALSE(is_local_source());
+  EXPECT_TRUE(loader()->range_supported());
+  EXPECT_EQ(BufferedResourceLoader::kReadThenDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+  set_might_be_reused_from_cache_in_future(true);
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kNeverDefer, defer_strategy());
+
+  data_source_->MediaIsPlaying();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+  set_might_be_reused_from_cache_in_future(false);
+  data_source_->MediaIsPaused();
+  EXPECT_EQ(BufferedResourceLoader::kCapacityDefer, defer_strategy());
+
+  Stop();
+}
+
 }  // namespace content