fully cache small audio/video

media/blink/multibuffer_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 221 matching lines @@
     view_->SetMainFrame(frame);
     url_index_ = make_linked_ptr(new TestUrlIndex(frame));
   }
 
   virtual ~MultibufferDataSourceTest() { view_->Close(); }
 
   MOCK_METHOD1(OnInitialize, void(bool));
 
   void InitializeWithCORS(const char* url,
                           bool expected,
-                          UrlData::CORSMode cors_mode) {
+                          UrlData::CORSMode cors_mode,
+                          size_t file_size = kFileSize) {
     GURL gurl(url);
     data_source_.reset(new MockMultibufferDataSource(
         gurl, cors_mode, message_loop_.task_runner(), url_index_,
         view_->MainFrame()->ToWebLocalFrame(), &host_));
     data_source_->SetPreload(preload_);
 
-    response_generator_.reset(new TestResponseGenerator(gurl, kFileSize));
+    response_generator_.reset(new TestResponseGenerator(gurl, file_size));
     EXPECT_CALL(*this, OnInitialize(expected));
     data_source_->Initialize(base::Bind(
         &MultibufferDataSourceTest::OnInitialize, base::Unretained(this)));
     base::RunLoop().RunUntilIdle();
 
     // Not really loading until after OnInitialize is called.
     EXPECT_EQ(data_source_->downloading(), false);
   }
 
-  void Initialize(const char* url, bool expected) {
-    InitializeWithCORS(url, expected, UrlData::CORS_UNSPECIFIED);
+  void Initialize(const char* url,
+                  bool expected,
+                  size_t file_size = kFileSize) {
+    InitializeWithCORS(url, expected, UrlData::CORS_UNSPECIFIED, file_size);
   }
 
   // Helper to initialize tests with a valid 200 response.
   void InitializeWith200Response() {
     Initialize(kHttpUrl, true);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate200());
 
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
     ReceiveData(kDataSize);
   }
 
   // Helper to initialize tests with a valid 206 response.
-  void InitializeWith206Response() {
-    Initialize(kHttpUrl, true);
+  void InitializeWith206Response(size_t file_size = kFileSize) {
+    Initialize(kHttpUrl, true, file_size);
 
     EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
     Respond(response_generator_->Generate206(0));
     EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
     ReceiveData(kDataSize);
   }
 
   // Helper to initialize tests with a valid file:// response.
   void InitializeWithFileResponse() {
     Initialize(kFileUrl, true);
@@ skipping 1221 matching lines @@
   response.SetHTTPHeaderField(WebString::FromUTF8("Etag"),
                               WebString::FromUTF8(etag));
   Respond(response);
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
   ReceiveData(kDataSize);
 
   EXPECT_EQ(url_data()->etag(), etag);
 }
 
 TEST_F(MultibufferDataSourceTest, CheckBufferSizes) {
-  InitializeWith206Response();
+  InitializeWith206Response(1 << 30);  // 1 gb
 
   data_source_->SetBitrate(1 << 20);  // 1 mbit / s
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1 << 20, data_source_bitrate());
   EXPECT_EQ(2 << 20, preload_low());
   EXPECT_EQ(3 << 20, preload_high());
   EXPECT_EQ(25 << 20, max_buffer_forward());
   EXPECT_EQ(2 << 20, max_buffer_backward());
   EXPECT_EQ(1572864 /* 1.5Mb */, buffer_size());
 
@@ skipping 27 matching lines @@
   data_source_->SetBitrate(80 << 20);  // 80 mbit / s
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(80 << 20, data_source_bitrate());
   EXPECT_EQ(50 << 20, preload_low());
   EXPECT_EQ(51 << 20, preload_high());
   EXPECT_EQ(51 << 20, max_buffer_forward());
   EXPECT_EQ(20 << 20, max_buffer_backward());
   EXPECT_EQ(71 << 20, buffer_size());
 }
 
+TEST_F(MultibufferDataSourceTest, CheckBufferSizeForSmallFiles) {
+  InitializeWith206Response();
+
+  data_source_->SetBitrate(1 << 20);  // 1 mbit / s
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(1 << 20, data_source_bitrate());
+  EXPECT_EQ(2 << 20, preload_low());
+  EXPECT_EQ(3 << 20, preload_high());
+  EXPECT_EQ(25 << 20, max_buffer_forward());
+  EXPECT_EQ(kFileSize * 2, max_buffer_backward());
+  EXPECT_EQ(5013504 /* file size rounted up to blocks size */, buffer_size());
+
+  data_source_->SetBitrate(80 << 20);  // 80 mbit / s
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(80 << 20, data_source_bitrate());
+  EXPECT_EQ(50 << 20, preload_low());
+  EXPECT_EQ(51 << 20, preload_high());
+  EXPECT_EQ(51 << 20, max_buffer_forward());
+  EXPECT_EQ(20 << 20, max_buffer_backward());
+  EXPECT_EQ(5013504 /* file size rounted up to blocks size */, buffer_size());
+}
+
 // Provoke an edge case where the loading state may not end up transitioning
 // back to "idle" when we're done loading.
 TEST_F(MultibufferDataSourceTest, Http_CheckLoadingTransition) {
   GURL gurl(kHttpUrl);
   data_source_.reset(new MockMultibufferDataSource(
       gurl, UrlData::CORS_UNSPECIFIED, message_loop_.task_runner(), url_index_,
       view_->MainFrame()->ToWebLocalFrame(), &host_));
   data_source_->SetPreload(preload_);
 
   response_generator_.reset(new TestResponseGenerator(gurl, kDataSize * 1));
@@ skipping 21 matching lines @@
                      base::Bind(&MultibufferDataSourceTest::ReadCallback,
                                 base::Unretained(this)));
   base::RunLoop().RunUntilIdle();
 
   // Make sure we're not downloading anymore.
   EXPECT_EQ(data_source_->downloading(), false);
   Stop();
 }
 
 }  // namespace media