Remove all synchronous methods from OfflinePageBridge.

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 101 matching lines @@
   // queue.
   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();
+  MultipleOfflinePageItemResult GetPagesByClientIds(
+      const std::vector<ClientId>& client_ids);
+  void DeletePagesByClientIds(const std::vector<ClientId>& client_ids);
 
   // 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 DeletePageCallback& callback) {
@@ skipping 191 matching lines @@
 
 MultipleOfflinePageItemResult OfflinePageModelImplTest::GetAllPages() {
   MultipleOfflinePageItemResult result;
   model()->GetAllPages(
       base::Bind(&OfflinePageModelImplTest::OnGetMultipleOfflinePageItemsResult,
                  AsWeakPtr(), base::Unretained(&result)));
   PumpLoop();
   return result;
 }
 
+MultipleOfflinePageItemResult OfflinePageModelImplTest::GetPagesByClientIds(
+    const std::vector<ClientId>& client_ids) {
+  MultipleOfflinePageItemResult result;
+  model()->GetPagesByClientIds(
+      client_ids,
+      base::Bind(&OfflinePageModelImplTest::OnGetMultipleOfflinePageItemsResult,
+                 AsWeakPtr(), base::Unretained(&result)));
+  PumpLoop();
+  return result;
+}
+
+void OfflinePageModelImplTest::DeletePagesByClientIds(
+    const std::vector<ClientId>& client_ids) {
+  model()->DeletePagesByClientIds(
+      client_ids,
+      base::Bind(&OfflinePageModelImplTest::OnDeletePageDone, AsWeakPtr()));
+  PumpLoop();
+}
+
 CheckPagesExistOfflineResult OfflinePageModelImplTest::CheckPagesExistOffline(
     std::set<GURL> pages) {
   model()->CheckPagesExistOffline(
       pages, base::Bind(&OfflinePageModelImplTest::OnCheckPagesExistOfflineDone,
                         AsWeakPtr()));
   PumpLoop();
   return last_pages_exist_result_;
 }
 
 MultipleOfflineIdResult OfflinePageModelImplTest::GetOfflineIdsForClientId(
@@ skipping 686 matching lines @@
   PumpLoop();
   // No change when we delete the last page.
   histograms().ExpectTotalCount(
       "OfflinePages.DownloadDeletedPageDuplicateCount", 2);
   histograms().ExpectBucketCount(
       "OfflinePages.DownloadDeletedPageDuplicateCount", 1, 1);
   histograms().ExpectBucketCount(
       "OfflinePages.DownloadDeletedPageDuplicateCount", 2, 1);
 }
 
-TEST_F(OfflinePageModelImplTest, 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_F(OfflinePageModelImplTest, ExpirePages) {
   // We will save 3 pages and then expire 2 of them.
   std::pair<SavePageResult, int64_t> saved_pages[3];
   saved_pages[0] = SavePage(kTestUrl, kTestClientId1);
   saved_pages[1] = SavePage(kTestUrl2, kTestClientId2);
   saved_pages[2] = SavePage(kTestUrl3, kTestClientId3);
 
   for (const auto& save_result : saved_pages) {
     ASSERT_EQ(OfflinePageModel::SavePageResult::SUCCESS,
               std::get<0>(save_result));
@@ skipping 18 matching lines @@
       EXPECT_EQ(expiration_time, offline_page.expiration_time);
       EXPECT_TRUE(offline_page.IsExpired());
     } else {
       EXPECT_EQ(base::Time(), offline_page.expiration_time);
       EXPECT_FALSE(offline_page.IsExpired());
     }
   }
   EXPECT_TRUE(last_expire_page_result());
 }
 
+TEST_F(OfflinePageModelImplTest, GetPagesByClientIds) {
+  // We will save 3 pages.  One will be expired.
+  std::pair<SavePageResult, int64_t> saved_pages[3];
+  saved_pages[0] = SavePage(kTestUrl, kTestClientId1);
+  saved_pages[1] = SavePage(kTestUrl2, kTestClientId2);
+  saved_pages[2] = SavePage(kTestUrl3, kTestClientId3);
+
+  for (const auto& save_result : saved_pages) {
+    ASSERT_EQ(OfflinePageModel::SavePageResult::SUCCESS,
+              std::get<0>(save_result));
+  }
+
+  std::vector<int64_t> pages_to_expire = {std::get<1>(saved_pages[0])};
+  // Pages are marked as expired if they have an expiration_time set.
+  base::Time expiration_time =
+      base::Time::Now() + base::TimeDelta::FromMinutes(5);
+  model()->ExpirePages(
+      pages_to_expire, expiration_time,
+      base::Bind(&OfflinePageModelImplTest::OnPagesExpired, AsWeakPtr()));
+  PumpLoop();
+
+  std::vector<ClientId> client_ids = {kTestClientId1, kTestClientId2};
+  std::vector<OfflinePageItem> offline_pages = GetPagesByClientIds(client_ids);
+  EXPECT_EQ(1U, offline_pages.size());
+
+  const OfflinePageItem& item = offline_pages[0];
+  EXPECT_EQ(kTestClientId2.name_space, item.client_id.name_space);
+  EXPECT_EQ(kTestClientId2.id, item.client_id.id);
+  EXPECT_EQ(kTestUrl2, item.url);
+}
+
+TEST_F(OfflinePageModelImplTest, DeletePagesByClientIds) {
+  // We will save 3 pages.
+  std::pair<SavePageResult, int64_t> saved_pages[3];
+  saved_pages[0] = SavePage(kTestUrl, kTestClientId1);
+  saved_pages[1] = SavePage(kTestUrl2, kTestClientId2);
+  saved_pages[2] = SavePage(kTestUrl3, kTestClientId3);
+
+  for (const auto& save_result : saved_pages) {
+    ASSERT_EQ(OfflinePageModel::SavePageResult::SUCCESS,
+              std::get<0>(save_result));
+  }
+
+  std::vector<ClientId> client_ids = {kTestClientId1, kTestClientId2};
+  DeletePagesByClientIds(client_ids);
+  std::vector<OfflinePageItem> offline_pages = GetAllPages();
+  ASSERT_EQ(1U, offline_pages.size());
+
+  const OfflinePageItem& item = offline_pages[0];
+  EXPECT_EQ(kTestClientId3.name_space, item.client_id.name_space);
+  EXPECT_EQ(kTestClientId3.id, item.client_id.id);
+  EXPECT_EQ(kTestUrl3, item.url);
+}
+
 TEST_F(OfflinePageModelImplTest, CustomTabsNamespace) {
   SavePage(kTestUrl, ClientId(kCCTNamespace, "123"));
   std::string histogram_name = "OfflinePages.SavePageResult.";
   histogram_name += kCCTNamespace;
 
   histograms().ExpectUniqueSample(histogram_name,
                                   static_cast<int>(SavePageResult::SUCCESS), 1);
 }
 
 TEST_F(OfflinePageModelImplTest, DownloadNamespace) {
@@ skipping 75 matching lines @@
   // Check if feature is correctly enabled by command-line flag.
   scoped_feature_list.reset(new base::test::ScopedFeatureList);
   scoped_feature_list->InitFromCommandLine(
       std::string(kOfflineBookmarksFeature.name) + "," +
           kOfflinePagesSharingFeature.name,
       "");
   EXPECT_TRUE(offline_pages::IsOfflinePagesSharingEnabled());
 }
 
 }  // namespace offline_pages