Choose the best offline page when given an online URL.

components/offline_pages/offline_page_model_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.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 105 matching lines @@
   void PumpLoop();
   // Fast-forwards virtual time by |delta|, causing tasks with a remaining
   // delay less than or equal to |delta| to be executed.
   void FastForwardBy(base::TimeDelta delta);
   void ResetResults();
 
   OfflinePageTestStore* GetStore();
 
   MultipleOfflinePageItemResult GetAllPages();
 
-  void SavePage(const GURL& url, ClientId client_id);
+  // Returns the offline ID of the saved page.
+  std::pair<SavePageResult, int64_t> SavePage(const GURL& url,
+                                              ClientId client_id);
 
   void SavePageWithArchiverResult(const GURL& url,
                                   ClientId client_id,
                                   OfflinePageArchiver::ArchiverResult result);
 
   void DeletePage(int64_t offline_id,
                   const OfflinePageModel::DeletePageCallback& callback) {
     std::vector<int64_t> offline_ids;
     offline_ids.push_back(offline_id);
     model()->DeletePagesByOfflineId(offline_ids, callback);
@@ skipping 164 matching lines @@
   last_delete_result_ = DeletePageResult::CANCELLED;
   last_archiver_path_.clear();
   last_pages_exist_result_.clear();
   last_cleared_pages_count_ = 0;
 }
 
 OfflinePageTestStore* OfflinePageModelTest::GetStore() {
   return static_cast<OfflinePageTestStore*>(model()->GetStoreForTesting());
 }
 
-void OfflinePageModelTest::SavePage(const GURL& url, ClientId client_id) {
+std::pair<SavePageResult, int64_t> OfflinePageModelTest::SavePage(
+    const GURL& url,
+    ClientId client_id) {
   SavePageWithArchiverResult(
       url, client_id,
       OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED);
+  return std::make_pair(last_save_result_, last_save_offline_id_);
 }
 
 void OfflinePageModelTest::SavePageWithArchiverResult(
     const GURL& url,
     ClientId client_id,
     OfflinePageArchiver::ArchiverResult result) {
   std::unique_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(url, result));
   model()->SavePage(
       url, client_id, std::move(archiver),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
@@ skipping 651 matching lines @@
   PumpLoop();
 
   std::vector<OfflinePageItem> offline_pages = GetAllPages();
 
   EXPECT_EQ(1UL, offline_pages.size());
   EXPECT_EQ(1UL, GetStore()->GetAllPages().size());
   EXPECT_EQ(2, last_cleared_pages_count());
   EXPECT_EQ(DeletePageResult::SUCCESS, last_clear_page_result());
 }
 
+TEST_F(OfflinePageModelTest, GetBestPage) {
+  // We will save 3 pages - two for the same URL, and one for a different URL.
+  // Correct behavior will pick the most recently saved page for the correct
+  // URL.
+  std::pair<SavePageResult, int64_t> saved_pages[3];
+  saved_pages[0] = SavePage(kTestUrl, kTestClientId1);
+  saved_pages[1] = SavePage(kTestUrl, kTestClientId1);
+  saved_pages[2] = SavePage(kTestUrl2, kTestClientId2);
+
+  for (const auto& save_result : saved_pages) {
+    ASSERT_EQ(OfflinePageModel::SavePageResult::SUCCESS,
+              std::get<0>(save_result));
+  }
+
+  const OfflinePageItem* offline_page =
+      model()->MaybeGetBestPageForOnlineURL(kTestUrl);
+  ASSERT_TRUE(nullptr != offline_page);
+
+  EXPECT_EQ(std::get<1>(saved_pages[1]), offline_page->offline_id);
+}
+
 TEST(CommandLineFlagsTest, OfflineBookmarks) {
   // Disabled by default.
   EXPECT_FALSE(offline_pages::IsOfflineBookmarksEnabled());
 
   // Check if feature is correctly enabled by command-line flag.
   base::FeatureList::ClearInstanceForTesting();
   std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
   feature_list->InitializeFromCommandLine(
       offline_pages::kOfflineBookmarksFeature.name, "");
   base::FeatureList::SetInstance(std::move(feature_list));
@@ skipping 40 matching lines @@
   std::unique_ptr<base::FeatureList> feature_list2(new base::FeatureList);
   feature_list2->InitializeFromCommandLine(
       std::string(offline_pages::kOfflineBookmarksFeature.name) + "," +
           offline_pages::kOfflinePagesBackgroundLoadingFeature.name,
       "");
   base::FeatureList::SetInstance(std::move(feature_list2));
   EXPECT_TRUE(offline_pages::IsOfflinePagesBackgroundLoadingEnabled());
 }
 
 }  // namespace offline_pages