Trigger redirect for offline pages

chrome/browser/android/offline_pages/offline_page_request_job_unittest.cc

 // Copyright 2016 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 "chrome/browser/android/offline_pages/offline_page_request_job.h"
 
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
@@ skipping 29 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace offline_pages {
 
 namespace {
 
 const GURL kTestUrl("http://test.org/page1");
 const GURL kTestUrl2("http://test.org/page2");
 const GURL kTestUrl3("http://test.org/page3");
 const GURL kTestUrl3WithFragment("http://test.org/page3#ref1");
+const GURL kTestOriginalUrl("http://test.org/first");
 const ClientId kTestClientId = ClientId(kBookmarkNamespace, "1234");
 const ClientId kTestClientId2 = ClientId(kDownloadNamespace, "1a2b3c4d");
 const ClientId kTestClientId3 = ClientId(kDownloadNamespace, "3456abcd");
 const int kTestFileSize = 444;
 const int kTestFileSize2 = 450;
 const int kTestFileSize3 = 450;
 const int kTabId = 1;
 const int kBufSize = 1024;
 const char kAggregatedRequestResultHistogram[] =
     "OfflinePages.AggregatedRequestResult2";
@@ skipping 172 matching lines @@
   ~OfflinePageRequestJobTest() override {}
 
   void SetUp() override;
   void TearDown() override;
 
   void SimulateHasNetworkConnectivity(bool has_connectivity);
   void RunUntilIdle();
 
   void SavePage(const GURL& url,
                 const ClientId& client_id,
+                const GURL& original_url,

[fgorski, 2016/11/17 17:37:48]

nit: This is quirky (you know me), but could GURLs stick together?

[jianli, 2016/11/17 23:42:06]

I thought about this but decided to go with this since the order is consistent
with the fields defined in SavePageParam.

                 std::unique_ptr<OfflinePageArchiver> archiver);
 
   void InterceptRequest(const GURL& url,
                         const std::string& method,
                         const std::string& extra_header_name,
                         const std::string& extra_header_value,
                         content::ResourceType resource_type);
 
   void ExpectAggregatedRequestResultHistogram(
       OfflinePageRequestJob::AggregatedRequestResult result);
@@ skipping 95 matching lines @@
   // residing in test data directory.
   base::FilePath test_data_dir_path;
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir_path));
 
   // Save an offline page.
   base::FilePath archive_file_path =
       test_data_dir_path.AppendASCII("offline_pages").AppendASCII("test.mhtml");
   std::unique_ptr<TestOfflinePageArchiver> archiver(
       new TestOfflinePageArchiver(kTestUrl, archive_file_path, kTestFileSize));
 
-  SavePage(kTestUrl, kTestClientId, std::move(archiver));
+  SavePage(kTestUrl, kTestClientId, GURL(), std::move(archiver));
 
   // Save another offline page associated with same online URL as above, but
   // pointing to different archive file.
   base::FilePath archive_file_path2 =
       test_data_dir_path.AppendASCII("offline_pages").
           AppendASCII("hello.mhtml");
   std::unique_ptr<TestOfflinePageArchiver> archiver2(
       new TestOfflinePageArchiver(
           kTestUrl, archive_file_path2, kTestFileSize2));
 
   // Make sure that the creation time of 2nd offline file is later.
   clock_.Advance(base::TimeDelta::FromMinutes(10));
 
-  SavePage(kTestUrl, kTestClientId2, std::move(archiver2));
+  SavePage(kTestUrl, kTestClientId2, GURL(), std::move(archiver2));
 
   // Save an offline page associated with online URL that has a fragment
   // identifier.
   base::FilePath archive_file_path3 =
       test_data_dir_path.AppendASCII("offline_pages").
           AppendASCII("hello.mhtml");
   std::unique_ptr<TestOfflinePageArchiver> archiver3(
       new TestOfflinePageArchiver(
           kTestUrl3WithFragment, archive_file_path3, kTestFileSize3));
 
-  SavePage(kTestUrl3WithFragment, kTestClientId3, std::move(archiver3));
+  SavePage(kTestUrl3WithFragment, kTestClientId3, kTestOriginalUrl,
+      std::move(archiver3));
 
   // Create a context with delayed initialization.
   test_url_request_context_.reset(new net::TestURLRequestContext(true));
 
   test_previews_decider_.reset(new TestPreviewsDecider());
 
   // Install the interceptor.
   std::unique_ptr<net::URLRequestInterceptor> interceptor(
       new OfflinePageRequestInterceptor(test_previews_decider_.get()));
   std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory_impl(
@@ skipping 59 matching lines @@
 
 void OfflinePageRequestJobTest::ExpectAggregatedRequestResultHistogramWithCount(
     OfflinePageRequestJob::AggregatedRequestResult result, int count) {
   histogram_tester_.ExpectUniqueSample(
       kAggregatedRequestResultHistogram, static_cast<int>(result), count);
 }
 
 void OfflinePageRequestJobTest::SavePage(
     const GURL& url,
     const ClientId& client_id,
+    const GURL& original_url,
     std::unique_ptr<OfflinePageArchiver> archiver) {
   OfflinePageModel::SavePageParams save_page_params;
   save_page_params.url = url;
   save_page_params.client_id = client_id;
+  save_page_params.original_url = original_url;
   OfflinePageModelFactory::GetForBrowserContext(profile())->SavePage(
       save_page_params,
       std::move(archiver),
       base::Bind(&OfflinePageRequestJobTest::OnSavePageDone,
                  base::Unretained(this)));
   RunUntilIdle();
 }
 
 void OfflinePageRequestJobTest::OnSavePageDone(SavePageResult result,
                                                int64_t offline_id) {
@@ skipping 340 matching lines @@
   EXPECT_EQ(kTestFileSize3, bytes_read());
   ASSERT_TRUE(offline_page_tab_helper()->GetOfflinePageForTest());
   EXPECT_EQ(offline_id3(),
             offline_page_tab_helper()->GetOfflinePageForTest()->offline_id);
   ExpectAggregatedRequestResultHistogramWithCount(
       OfflinePageRequestJob::AggregatedRequestResult::
           SHOW_OFFLINE_ON_DISCONNECTED_NETWORK, 3);
 
 }
 
+TEST_F(OfflinePageRequestJobTest, LoadOfflinePageAfterRedirect) {
+  SimulateHasNetworkConnectivity(false);
+
+  // This should trigger redirect first.
+  InterceptRequest(
+      kTestOriginalUrl, "GET", "", "", content::RESOURCE_TYPE_MAIN_FRAME);
+  base::RunLoop().Run();
+
+  EXPECT_EQ(kTestFileSize3, bytes_read());
+  ASSERT_TRUE(offline_page_tab_helper()->GetOfflinePageForTest());
+  EXPECT_EQ(offline_id3(),
+            offline_page_tab_helper()->GetOfflinePageForTest()->offline_id);
+  ExpectAggregatedRequestResultHistogram(
+      OfflinePageRequestJob::AggregatedRequestResult::
+          SHOW_OFFLINE_ON_DISCONNECTED_NETWORK);
+}
+
 }  // namespace offline_pages