[Offline Pages] Updated clearing logic in storage manager.

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 11 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_client_policy.h"
 #include "components/offline_pages/offline_page_feature.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_storage_manager.h"
 #include "components/offline_pages/offline_page_test_archiver.h"
 #include "components/offline_pages/offline_page_test_store.h"
 #include "components/offline_pages/offline_page_types.h"
+#include "components/prefs/testing_pref_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace offline_pages {
 
 namespace {
 const char kTestClientNamespace[] = "CLIENT_NAMESPACE";
 const GURL kTestUrl("http://example.com");
 const GURL kTestUrl2("http://other.page.com");
 const GURL kTestUrl3("http://test.xyz");
@@ skipping 38 matching lines @@
   void OnCheckPagesExistOfflineDone(const CheckPagesExistOfflineResult& result);
   void OnClearAllDone();
   void OnGetOfflineIdsForClientIdDone(MultipleOfflineIdResult* storage,
                                       const MultipleOfflineIdResult& result);
   void OnGetSingleOfflinePageItemResult(
       SingleOfflinePageItemResult* storage,
       const SingleOfflinePageItemResult& result);
   void OnGetMultipleOfflinePageItemsResult(
       MultipleOfflinePageItemResult* storage,
       const MultipleOfflinePageItemResult& result);
-  void OnClearPageByStorageManager(int pages_cleared, DeletePageResult result);
 
   // OfflinePageMetadataStore callbacks.
   void OnStoreUpdateDone(bool /* success */);
 
   std::unique_ptr<OfflinePageTestArchiver> BuildArchiver(
       const GURL& url,
       OfflinePageArchiver::ArchiverResult result);
   std::unique_ptr<OfflinePageMetadataStore> BuildStore();
   std::unique_ptr<OfflinePageModel> BuildModel(
       std::unique_ptr<OfflinePageMetadataStore> store);
@@ skipping 158 matching lines @@
 }
 
 std::unique_ptr<OfflinePageMetadataStore> OfflinePageModelTest::BuildStore() {
   return std::unique_ptr<OfflinePageMetadataStore>(
       new OfflinePageTestStore(base::ThreadTaskRunnerHandle::Get()));
 }
 
 std::unique_ptr<OfflinePageModel> OfflinePageModelTest::BuildModel(
     std::unique_ptr<OfflinePageMetadataStore> store) {
   return std::unique_ptr<OfflinePageModel>(new OfflinePageModel(
-      std::move(store), temp_dir_.path(), base::ThreadTaskRunnerHandle::Get()));
+      std::move(store), temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
+      new TestingPrefServiceSimple()));
 }
 
 void OfflinePageModelTest::ResetModel() {
   model_->RemoveObserver(this);
   OfflinePageTestStore* old_store = GetStore();
   std::unique_ptr<OfflinePageMetadataStore> new_store(
       new OfflinePageTestStore(*old_store));
   model_ = BuildModel(std::move(new_store));
   model_->AddObserver(this);
   PumpLoop();
@@ skipping 101 matching lines @@
     const SingleOfflinePageItemResult& result) {
   *storage = result;
 }
 
 void OfflinePageModelTest::OnGetMultipleOfflinePageItemsResult(
     MultipleOfflinePageItemResult* storage,
     const MultipleOfflinePageItemResult& result) {
   *storage = result;
 }
 
-void OfflinePageModelTest::OnClearPageByStorageManager(
-    int pages_cleared,
-    DeletePageResult result) {
-  last_cleared_pages_count_ = pages_cleared;
-  last_clear_page_result_ = result;
-}
-
 base::Optional<OfflinePageItem> OfflinePageModelTest::GetPagesByOnlineURL(
     const GURL& online_url) {
   MultipleOfflinePageItemResult result;
   model()->GetPagesByOnlineURL(
       online_url,
       base::Bind(&OfflinePageModelTest::OnGetMultipleOfflinePageItemsResult,
                  AsWeakPtr(), base::Unretained(&result)));
   PumpLoop();
   if (result.size() > 0)
     return base::make_optional(result[0]);
@@ skipping 528 matching lines @@
 
   std::set<int64_t> id_set;
   for (size_t i = 0; i < ids.size(); i++) {
     id_set.insert(ids[i]);
   }
 
   EXPECT_TRUE(id_set.find(offline1) != id_set.end());
   EXPECT_TRUE(id_set.find(offline2) != id_set.end());
 }
 
-TEST_F(OfflinePageModelTest, ClearPagesFromOneSource) {
-  base::Time now = base::Time::Now();
-  base::TimeDelta expiration_period = model()
-                                          ->GetPolicyController()
-                                          ->GetPolicy(kTestClientNamespace)
-                                          .lifetime_policy.expiration_period;
-
-  SavePage(kTestUrl, kTestClientId1);
-  GetStore()->UpdateLastAccessTime(
-      last_save_offline_id(),
-      now - base::TimeDelta::FromDays(10) - expiration_period);
-  SavePage(kTestUrl2, kTestClientId2);
-  GetStore()->UpdateLastAccessTime(
-      last_save_offline_id(),
-      now - base::TimeDelta::FromDays(1) - expiration_period);
-  SavePage(kTestUrl3, kTestClientId3);
-  GetStore()->UpdateLastAccessTime(last_save_offline_id(), now);
-
-  ResetModel();
-
-  // Only first two pages are expired.
-  model()->GetStorageManager()->ClearPagesIfNeeded(base::Bind(
-      &OfflinePageModelTest::OnClearPageByStorageManager, AsWeakPtr()));
-
-  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) {
@@ skipping 61 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