[Offline Pages] Implement OfflinePageStorageManager.

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "components/offline_pages/client_policy_controller.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 "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
 using DeletePageResult = offline_pages::OfflinePageModel::DeletePageResult;
 using SingleOfflinePageItemResult =
     offline_pages::OfflinePageModel::SingleOfflinePageItemResult;
 using MultipleOfflinePageItemResult =
@@ skipping 51 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 48 matching lines @@
   DeletePageResult last_delete_result() const {
     return last_delete_result_;
   }
 
   int64_t last_deleted_offline_id() const { return last_deleted_offline_id_; }
 
   ClientId last_deleted_client_id() const { return last_deleted_client_id_; }
 
   const base::FilePath& last_archiver_path() { return last_archiver_path_; }
 
+  int last_cleared_pages_count() const { return last_cleared_pages_count_; }
+
+  DeletePageResult last_clear_page_result() const {
+    return last_clear_page_result_;
+  }
+
  private:
   scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   base::ScopedTempDir temp_dir_;
 
   std::unique_ptr<OfflinePageModel> model_;
   SavePageResult last_save_result_;
   int64_t last_save_offline_id_;
   DeletePageResult last_delete_result_;
   base::FilePath last_archiver_path_;
   int64_t last_deleted_offline_id_;
   ClientId last_deleted_client_id_;
   bool last_has_pages_result_;
   CheckPagesExistOfflineResult last_pages_exist_result_;
+  int last_cleared_pages_count_;
+  DeletePageResult last_clear_page_result_;
 };
 
 OfflinePageModelTest::OfflinePageModelTest()
     : task_runner_(new base::TestMockTimeTaskRunner),
       task_runner_handle_(task_runner_),
       last_save_result_(SavePageResult::CANCELLED),
       last_save_offline_id_(-1),
       last_delete_result_(DeletePageResult::CANCELLED),
       last_deleted_offline_id_(-1) {}
 
@@ skipping 93 matching lines @@
 
 void OfflinePageModelTest::FastForwardBy(base::TimeDelta delta) {
   task_runner_->FastForwardBy(delta);
 }
 
 void OfflinePageModelTest::ResetResults() {
   last_save_result_ = SavePageResult::CANCELLED;
   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) {
   SavePageWithArchiverResult(
       url, client_id,
       OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED);
@@ skipping 72 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_delete_result());

[fgorski, 2016/05/06 05:57:24]

last_clear_page_result()

[romax, 2016/05/07 02:22:42]

Done.

+}
+
 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