Support getting offline pages also by original URL

components/offline_pages/offline_page_model_impl_unittest.cc

 // Copyright 2015 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 "components/offline_pages/offline_page_model_impl.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 140 matching lines @@
   }
 
   bool HasPages(std::string name_space);
 
   CheckPagesExistOfflineResult CheckPagesExistOffline(std::set<GURL>);
 
   MultipleOfflineIdResult GetOfflineIdsForClientId(const ClientId& client_id);
 
   std::unique_ptr<OfflinePageItem> GetPageByOfflineId(int64_t offline_id);
 
-  MultipleOfflinePageItemResult GetPagesByOnlineURL(const GURL& online_url);
+  MultipleOfflinePageItemResult GetPagesByFinalURL(const GURL& url);
+  MultipleOfflinePageItemResult GetPagesByAnyURL(const GURL& url);
 
   OfflinePageModelImpl* model() { return model_.get(); }
 
   int64_t last_save_offline_id() const { return last_save_offline_id_; }
 
   SavePageResult last_save_result() const { return last_save_result_; }
 
   DeletePageResult last_delete_result() const { return last_delete_result_; }
 
   int64_t last_deleted_offline_id() const { return last_deleted_offline_id_; }
@@ skipping 265 matching lines @@
 void OfflinePageModelImplTest::OnGetMultipleOfflinePageItemsResult(
     MultipleOfflinePageItemResult* storage,
     const MultipleOfflinePageItemResult& result) {
   *storage = result;
 }
 
 void OfflinePageModelImplTest::OnPagesExpired(bool result) {
   last_expire_page_result_ = result;
 }
 
-MultipleOfflinePageItemResult OfflinePageModelImplTest::GetPagesByOnlineURL(
-    const GURL& online_url) {
+MultipleOfflinePageItemResult OfflinePageModelImplTest::GetPagesByFinalURL(
+    const GURL& url) {
   MultipleOfflinePageItemResult result;
-  model()->GetPagesByOnlineURL(
-      online_url,
+  model()->GetPagesByURL(
+      url,
+      true /* search_by_final_url_only */,
       base::Bind(&OfflinePageModelImplTest::OnGetMultipleOfflinePageItemsResult,
                  AsWeakPtr(), base::Unretained(&result)));
   PumpLoop();
+  return result;
+}
+
+MultipleOfflinePageItemResult OfflinePageModelImplTest::GetPagesByAnyURL(
+    const GURL& url) {
+  MultipleOfflinePageItemResult result;
+  model()->GetPagesByURL(
+      url,
+      false /* search_by_final_url_only */,
+      base::Bind(&OfflinePageModelImplTest::OnGetMultipleOfflinePageItemsResult,
+                 AsWeakPtr(), base::Unretained(&result)));
+  PumpLoop();
   return result;
 }
 
 bool OfflinePageModelImplTest::HasPages(std::string name_space) {
   MultipleOfflinePageItemResult all_pages = GetAllPages();
   for (const auto& page : all_pages) {
     if (page.client_id.name_space == name_space)
       return true;
   }
 
@@ skipping 452 matching lines @@
   page = GetPageByOfflineId(offline2);
   ASSERT_TRUE(page);
   EXPECT_EQ(kTestUrl2, page->url);
   EXPECT_EQ(kTestClientId2, page->client_id);
   EXPECT_EQ(kTestFileSize, page->file_size);
 
   page = GetPageByOfflineId(-42);
   EXPECT_FALSE(page);
 }
 
-TEST_F(OfflinePageModelImplTest, GetPagesByOnlineURL) {
+TEST_F(OfflinePageModelImplTest, GetPagesByFinalURL) {
   SavePage(kTestUrl, kTestClientId1);
   SavePage(kTestUrl2, kTestClientId2);
 
-  MultipleOfflinePageItemResult pages = GetPagesByOnlineURL(kTestUrl2);
+  MultipleOfflinePageItemResult pages = GetPagesByFinalURL(kTestUrl2);
   EXPECT_EQ(1U, pages.size());
   EXPECT_EQ(kTestUrl2, pages[0].url);
   EXPECT_EQ(kTestClientId2, pages[0].client_id);
 
-  pages = GetPagesByOnlineURL(kTestUrl);
+  pages = GetPagesByFinalURL(kTestUrl);
   EXPECT_EQ(1U, pages.size());
   EXPECT_EQ(kTestUrl, pages[0].url);
   EXPECT_EQ(kTestClientId1, pages[0].client_id);
 
-  pages = GetPagesByOnlineURL(GURL("http://foo"));
+  pages = GetPagesByFinalURL(GURL("http://foo"));
   EXPECT_EQ(0U, pages.size());
 }
 
-TEST_F(OfflinePageModelImplTest, GetPagesByOnlineURLWithFragment) {
+TEST_F(OfflinePageModelImplTest, GetPagesByFinalURLWithFragment) {
   SavePage(kTestUrl, kTestClientId1);
   SavePage(kTestUrl2WithFragment, kTestClientId2);
 
   MultipleOfflinePageItemResult pages =
-      GetPagesByOnlineURL(kTestUrlWithFragment);
+      GetPagesByFinalURL(kTestUrlWithFragment);
   EXPECT_EQ(1U, pages.size());
   EXPECT_EQ(kTestUrl, pages[0].url);
   EXPECT_EQ(kTestClientId1, pages[0].client_id);
 
-  pages = GetPagesByOnlineURL(kTestUrl2);
+  pages = GetPagesByFinalURL(kTestUrl2);
   EXPECT_EQ(1U, pages.size());
   EXPECT_EQ(kTestUrl2WithFragment, pages[0].url);
   EXPECT_EQ(kTestClientId2, pages[0].client_id);
 
-  pages = GetPagesByOnlineURL(kTestUrl2WithFragment2);
+  pages = GetPagesByFinalURL(kTestUrl2WithFragment2);
   EXPECT_EQ(1U, pages.size());
   EXPECT_EQ(kTestUrl2WithFragment, pages[0].url);
   EXPECT_EQ(kTestClientId2, pages[0].client_id);
 }
 
+TEST_F(OfflinePageModelImplTest, GetPagesByEitherOriginalURLOrFinalURL) {
+  std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+      kTestUrl, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
+  SavePageWithArchiverAsync(
+      kTestUrl, kTestClientId1, kTestUrl2, std::move(archiver));
+  PumpLoop();
+
+  SavePage(kTestUrl2, kTestClientId2);
+
+  MultipleOfflinePageItemResult pages = GetPagesByAnyURL(kTestUrl2);
+  ASSERT_EQ(2U, pages.size());
+  int i = -1;

[fgorski, 2016/11/16 23:43:46]

Add a comment about this trick.

[jianli, 2016/11/17 01:12:15]

Done.

+  if (pages[0].url == kTestUrl2)
+    i = 0;
+  else if (pages[1].url == kTestUrl2)
+    i = 1;
+  ASSERT_NE(-1, i);
+  EXPECT_EQ(kTestUrl2, pages[i].url);
+  EXPECT_EQ(kTestClientId2, pages[i].client_id);
+  EXPECT_EQ(GURL(), pages[i].original_url);
+  EXPECT_EQ(kTestUrl, pages[1 - i].url);
+  EXPECT_EQ(kTestClientId1, pages[1 - i].client_id);
+  EXPECT_EQ(kTestUrl2, pages[1 - i].original_url);
+}
+
 TEST_F(OfflinePageModelImplTest, CheckPagesExistOffline) {
   SavePage(kTestUrl, kTestClientId1);
   SavePage(kTestUrl2, kTestClientId2);
 
   // TODO(dewittj): Remove the "Last N" restriction in favor of a better query
   // interface.  See https://crbug.com/622763 for information.
   const ClientId last_n_client_id(kLastNNamespace, "1234");
   SavePage(kTestUrl3, last_n_client_id);
 
   std::set<GURL> input;
@@ skipping 281 matching lines @@
   EXPECT_FALSE(offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled());
 
   // Check if feature is correctly enabled by command-line flag.
   base::test::ScopedFeatureList scoped_feature_list;
   scoped_feature_list.InitAndEnableFeature(
       kOfflinePagesSvelteConcurrentLoadingFeature);
   EXPECT_TRUE(offline_pages::IsOfflinePagesSvelteConcurrentLoadingEnabled());
 }
 
 }  // namespace offline_pages