BufferedDataSource now caches redirects for subsequent requests

media/blink/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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 278 matching lines @@
     return loader()->defer_strategy_;
   }
   int data_source_bitrate() { return data_source_->bitrate_; }
   double data_source_playback_rate() { return data_source_->playback_rate_; }
   int loader_bitrate() { return loader()->bitrate_; }
   double 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;
   }
+  GURL url() { return data_source_->url_; }
 
   std::unique_ptr<MockBufferedDataSource> data_source_;
 
   std::unique_ptr<TestResponseGenerator> response_generator_;
   MockWebFrameClient client_;
   WebView* view_;
   WebLocalFrame* frame_;
 
   StrictMock<MockBufferedDataSourceHost> host_;
   base::MessageLoop message_loop_;
@@ skipping 183 matching lines @@
   bytes_received_ = 0;
   loader()->didFail(url_loader(), response_generator_->GenerateError());
   run_loop.Run();
   Respond(response_generator_->Generate206(kDataSize));
   ReceiveData(kDataSize);
   FinishLoading();
   EXPECT_FALSE(data_source_->loading());
   Stop();
 }
 
+// If the initial response is a redirect, BDS saves it and uses it for future
+// requests.
+TEST_F(BufferedDataSourceTest, Http_InitialReponseRedirectsAreCached) {
+  Initialize(kHttpUrl, true);
+
+  WebURLResponse redirect =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  redirect.setURL(GURL(kHttpDifferentPathUrl));
+
+  EXPECT_CALL(host_, SetTotalBytes(kFileSize));
+  Respond(redirect);
+  ASSERT_TRUE(url() == GURL(kHttpDifferentPathUrl));
+}
+
+TEST_F(BufferedDataSourceTest,
+       Http_RedirectsAfterTheInitialReponseAreNotCached) {
+  Initialize(kHttpUrl, true);
+
+  WebURLResponse response =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  response.setURL(GURL(kHttpUrl));
+
+  EXPECT_CALL(host_, SetTotalBytes(kFileSize));
+  EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize - 1));
+  EXPECT_CALL(host_, AddBufferedByteRange(kDataSize, kDataSize * 2 - 1));
+  EXPECT_CALL(*this, ReadCallback(kDataSize)).Times(2);
+
+  Respond(response);
+  ReadAt(0);
+  ReceiveData(kDataSize);
+
+  WebURLResponse redirect =
+      response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
+  redirect.setURL(GURL(kHttpDifferentPathUrl));
+
+  ExpectCreateResourceLoader();
+  FinishLoading();
+  ReadAt(kDataSize);
+  Respond(redirect);
+  // The redirect isn't cached.
+  ASSERT_TRUE(url() == GURL(kHttpUrl));
+  ReceiveData(kDataSize);
+  FinishLoading();
+  Stop();
+}
+
+TEST_F(BufferedDataSourceTest, Http_ServiceWorkerRedirectsAreNotCached) {
+  Initialize(kHttpUrl, true);
+
+  WebURLResponse redirect =
+      response_generator_->GeneratePartial206(0, kDataSize - 1);
+  redirect.setURL(GURL(kHttpDifferentPathUrl));
+  redirect.setWasFetchedViaServiceWorker(true);
+
+  EXPECT_CALL(host_, SetTotalBytes(kFileSize));
+  Respond(redirect);
+  ASSERT_TRUE(url() == GURL(kHttpUrl));
+}
+
 TEST_F(BufferedDataSourceTest, Http_PartialResponse) {
   Initialize(kHttpUrl, true);
   WebURLResponse response1 =
       response_generator_->GeneratePartial206(0, kDataSize - 1);
   WebURLResponse response2 =
       response_generator_->GeneratePartial206(kDataSize, kDataSize * 2 - 1);
   // The origin URL of response1 and response2 are same. So no error should
   // occur.
   ExecuteMixedResponseSuccessTest(response1, response2);
 }
@@ skipping 531 matching lines @@
   while (active_loader() && !active_loader()->deferred()) {
     ReceiveData(kDataSize);
     bytes_received += kDataSize;
   }
   EXPECT_GT(bytes_received, 0);
   EXPECT_LT(bytes_received + kDataSize, kFileSize);
   EXPECT_FALSE(active_loader());
 }
 
 }  // namespace media