Implementing preload=metadata for video

webkit/glue/media/buffered_resource_loader_unittest.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
@@ skipping 158 matching lines @@
   void ReadLoader(int64 position, int size, uint8* buffer) {
     loader_->Read(position, size, buffer,
                   NewCallback(this, &BufferedResourceLoaderTest::ReadCallback));
   }
 
   // Verifis that data in buffer[0...size] is equal to data_[pos...pos+size].
   void VerifyBuffer(uint8* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
-  // Helper method to disallow deferring in |loader_|.
-  void DisallowLoaderDefer() {
-    if (loader_->deferred_) {
-      EXPECT_CALL(*url_loader_, setDefersLoading(false));
-      EXPECT_CALL(*this, NetworkCallback());
-    }
-    loader_->SetAllowDefer(false);
-  }
-
-  // Helper method to allow deferring in |loader_|.
-  void AllowLoaderDefer() {
-    loader_->SetAllowDefer(true);
+  void ConfirmLoaderDeferredState(bool expectedVal) {
+    EXPECT_EQ(loader_->deferred_, expectedVal);
   }
 
   MOCK_METHOD1(StartCallback, void(int error));
   MOCK_METHOD1(ReadCallback, void(int error));
   MOCK_METHOD0(NetworkCallback, void());
 
  protected:
   GURL gurl_;
   int64 first_position_;
   int64 last_position_;
@@ skipping 67 matching lines @@
                               WebString::fromUTF8(base::StringPrintf("bytes "
                                   "%d-%d/%d", 1, 10, 1024)));
   response.setExpectedContentLength(10);
   response.setHTTPStatusCode(kHttpPartialContent);
   loader_->didReceiveResponse(url_loader_, response);
 }
 
 // Tests the logic of sliding window for data buffering and reading.
 TEST_F(BufferedResourceLoaderTest, BufferAndRead) {
   Initialize(kHttpUrl, 10, 29);
+  loader_->UpdateDeferStrategy(BufferedResourceLoader::kThresholdDefer);
   Start();
   PartialResponse(10, 29, 30);
 
   uint8 buffer[10];
   InSequence s;
 
   // Writes 10 bytes and read them back.
   WriteLoader(10, 10);
   EXPECT_CALL(*this, ReadCallback(10));
   ReadLoader(10, 10, buffer);
@@ skipping 30 matching lines @@
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(5, 10, buffer);
 
   // Try to read beyond the instance size.
   EXPECT_CALL(*this, ReadCallback(0));
   ReadLoader(30, 10, buffer);
 }
 
 TEST_F(BufferedResourceLoaderTest, ReadOutsideBuffer) {
   Initialize(kHttpUrl, 10, 0x00FFFFFF);
+  loader_->UpdateDeferStrategy(BufferedResourceLoader::kThresholdDefer);
   Start();
   PartialResponse(10, 0x00FFFFFF, 0x01000000);
 
   uint8 buffer[10];
   InSequence s;
 
   // Read very far aheard will get a cache miss.
   EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(0x00FFFFFF, 1, buffer);
 
@@ skipping 23 matching lines @@
   InSequence s;
 
   ReadLoader(10, 10, buffer);
   EXPECT_CALL(*this, ReadCallback(net::ERR_FAILED));
   EXPECT_CALL(*this, NetworkCallback());
   WebURLError error;
   error.reason = net::ERR_FAILED;
   loader_->didFail(url_loader_, error);
 }
 
-// Tests the logic of caching data to disk when media is paused.
-TEST_F(BufferedResourceLoaderTest, AllowDefer_NoDataReceived) {
+// Tests the data buffering logic of NeverDefer strategy.
+TEST_F(BufferedResourceLoaderTest, NeverDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
-  Start();
-  PartialResponse(10, 99, 100);
-
-  // Start in undeferred state, then disallow defer, then allow defer
-  // without receiving data in between.
-  DisallowLoaderDefer();
-  AllowLoaderDefer();
-  StopWhenLoad();
-}
-
-TEST_F(BufferedResourceLoaderTest, AllowDefer_ReadSameWindow) {
-  Initialize(kHttpUrl, 10, 99);
-  SetLoaderBuffer(10, 20);
+  loader_->UpdateDeferStrategy(BufferedResourceLoader::kNeverDefer);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
-  // Start in undeferred state, disallow defer, receive data but don't shift
-  // buffer window, then allow defer and read.
-  DisallowLoaderDefer();
+  // Read past the buffer size; should not defer regardless.
   WriteLoader(10, 10);
-  AllowLoaderDefer();
+  WriteLoader(20, 50);
+  ConfirmLoaderDeferredState(false);
 
-  EXPECT_CALL(*this, ReadCallback(10));
+  // Should move past window.
+  EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
   ReadLoader(10, 10, buffer);
-  VerifyBuffer(buffer, 10, 10);
+
   StopWhenLoad();
 }
 
-TEST_F(BufferedResourceLoaderTest, AllowDefer_ReadPastWindow) {
+// Tests the data buffering logic of ReadThenDefer strategy.
+TEST_F(BufferedResourceLoaderTest, ReadThenDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
+  loader_->UpdateDeferStrategy(BufferedResourceLoader::kReadThenDefer);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
-  // Not deferred, disallow defer, received data and shift buffer window,
-  // allow defer, then read in area outside of buffer window.
-  DisallowLoaderDefer();
-  WriteLoader(10, 10);
-  WriteLoader(20, 50);
-  AllowLoaderDefer();
+  // Make an outstanding read request.
+  // We should disable deferring after the read request, so expect
+  // a network event.
+  EXPECT_CALL(*this, NetworkCallback());
+  ReadLoader(10, 10, buffer);
 
-  EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
-  ReadLoader(10, 10, buffer);
+  // Receive almost enough data to cover, shouldn't defer.
+  WriteLoader(10, 9);
+  ConfirmLoaderDeferredState(false);
+
+  // As soon as we have received enough data to fulfill the read, defer.
+  EXPECT_CALL(*this, NetworkCallback());
+  EXPECT_CALL(*this, ReadCallback(10));
+  WriteLoader(19, 1);
+
+  ConfirmLoaderDeferredState(true);
+  VerifyBuffer(buffer, 10, 10);
+
   StopWhenLoad();
 }
 
-TEST_F(BufferedResourceLoaderTest, AllowDefer_DeferredNoDataReceived) {
+// Tests the data buffering logic of ThresholdDefer strategy.
+TEST_F(BufferedResourceLoaderTest, ThresholdDeferStrategy) {
   Initialize(kHttpUrl, 10, 99);
   SetLoaderBuffer(10, 20);
+  loader_->UpdateDeferStrategy(BufferedResourceLoader::kThresholdDefer);
   Start();
   PartialResponse(10, 99, 100);
 
   uint8 buffer[10];
 
-  // Start in deferred state, then disallow defer, receive no data, and
-  // allow defer and read.
-  EXPECT_CALL(*url_loader_, setDefersLoading(true));
+  WriteLoader(10, 5);
+  // Haven't reached threshold, don't defer.
+  ConfirmLoaderDeferredState(false);
+
+  // We're at the threshold now, let's defer.
   EXPECT_CALL(*this, NetworkCallback());
-  WriteLoader(10, 40);
+  WriteLoader(15, 5);
+  ConfirmLoaderDeferredState(true);
 
-  DisallowLoaderDefer();
-  AllowLoaderDefer();
+  // Now we've read over half of the buffer, disable deferring.
+  EXPECT_CALL(*this, ReadCallback(6));
+  EXPECT_CALL(*this, NetworkCallback());
+  ReadLoader(10, 6, buffer);
 
-  EXPECT_CALL(*this, ReadCallback(10));
-  ReadLoader(20, 10, buffer);
-  VerifyBuffer(buffer, 20, 10);
+  ConfirmLoaderDeferredState(false);
+  VerifyBuffer(buffer, 10, 6);
+
   StopWhenLoad();
 }
 
-TEST_F(BufferedResourceLoaderTest, AllowDefer_DeferredReadSameWindow) {
-  Initialize(kHttpUrl, 10, 99);
-  SetLoaderBuffer(10, 20);
-  Start();
-  PartialResponse(10, 99, 100);
-
-  uint8 buffer[10];
-
-  // Start in deferred state, disallow defer, receive data and shift buffer
-  // window, allow defer, and read in a place that's still in the window.
-  EXPECT_CALL(*url_loader_, setDefersLoading(true));
-  EXPECT_CALL(*this, NetworkCallback());
-  WriteLoader(10, 30);
-
-  DisallowLoaderDefer();
-  WriteLoader(40, 5);
-  AllowLoaderDefer();
-
-  EXPECT_CALL(*this, ReadCallback(10));
-  ReadLoader(20, 10, buffer);
-  VerifyBuffer(buffer, 20, 10);
-  StopWhenLoad();
-}
-
-TEST_F(BufferedResourceLoaderTest, AllowDefer_DeferredReadPastWindow) {
-  Initialize(kHttpUrl, 10, 99);
-  SetLoaderBuffer(10, 20);
-  Start();
-  PartialResponse(10, 99, 100);
-
-  uint8 buffer[10];
-
-  // Start in deferred state, disallow defer, receive data and shift buffer
-  // window, allow defer, and read outside of the buffer window.
-  EXPECT_CALL(*url_loader_, setDefersLoading(true));
-  EXPECT_CALL(*this, NetworkCallback());
-  WriteLoader(10, 40);
-
-  DisallowLoaderDefer();
-  WriteLoader(50, 20);
-  WriteLoader(70, 40);
-  AllowLoaderDefer();
-
-  EXPECT_CALL(*this, ReadCallback(net::ERR_CACHE_MISS));
-  ReadLoader(20, 5, buffer);
-  StopWhenLoad();
-}
-
 // NOTE: This test will need to be reworked a little once
 // http://code.google.com/p/chromium/issues/detail?id=72578
 // is fixed.
 TEST_F(BufferedResourceLoaderTest, HasSingleOrigin) {
   // Make sure no redirect case works as expected.
   Initialize(kHttpUrl, -1, -1);
   Start();
   FullResponse(1024);
   EXPECT_TRUE(loader_->HasSingleOrigin());
   StopWhenLoad();
@@ skipping 27 matching lines @@
   Start();
   Redirect(kHttpRedirectToSameDomainUrl1);
   Redirect(kHttpRedirectToDifferentDomainUrl1);
   EXPECT_FALSE(loader_->HasSingleOrigin());
   StopWhenLoad();
 }
 
 // TODO(hclam): add unit test for defer loading.
 
 }  // namespace webkit_glue