[Offline pages] Adding capability to free up space used by Offline pages

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/time/time.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_metadata_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;
 
 namespace offline_pages {
 
 namespace {
 const GURL kTestUrl("http://example.com");
 const int64 kTestPageBookmarkId1 = 1234LL;
 const GURL kTestUrl2("http://other.page.com");
 const int64 kTestPageBookmarkId2 = 5678LL;
 const int64 kTestFileSize = 876543LL;
 
 class OfflinePageTestStore : public OfflinePageMetadataStore {
  public:
   enum class TestScenario {
     SUCCESSFUL,
     WRITE_FAILED,
     LOAD_FAILED,
     REMOVE_FAILED,
   };
 
   explicit OfflinePageTestStore(
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+  explicit OfflinePageTestStore(const OfflinePageTestStore& other_store);
   ~OfflinePageTestStore() override;
 
   // OfflinePageMetadataStore overrides:
   void Load(const LoadCallback& callback) override;
   void AddOfflinePage(const OfflinePageItem& offline_page,
                       const UpdateCallback& callback) override;
   void RemoveOfflinePages(const std::vector<int64>& bookmark_ids,
                           const UpdateCallback& callback) override;
   const OfflinePageItem& last_saved_page() const { return last_saved_page_; }
 
   void set_test_scenario(TestScenario scenario) { scenario_ = scenario; };
 
   const std::vector<OfflinePageItem>& offline_pages() const {
     return offline_pages_;
   }
 
  private:
   OfflinePageItem last_saved_page_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   TestScenario scenario_;
 
   std::vector<OfflinePageItem> offline_pages_;
 
-  DISALLOW_COPY_AND_ASSIGN(OfflinePageTestStore);
+  DISALLOW_ASSIGN(OfflinePageTestStore);
 };
 
 OfflinePageTestStore::OfflinePageTestStore(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
       scenario_(TestScenario::SUCCESSFUL) {
 }
 
+OfflinePageTestStore::OfflinePageTestStore(
+    const OfflinePageTestStore& other_store)
+    : task_runner_(other_store.task_runner_),
+      scenario_(other_store.scenario_),
+      offline_pages_(other_store.offline_pages_) {}
+
 OfflinePageTestStore::~OfflinePageTestStore() {
 }
 
 void OfflinePageTestStore::Load(const LoadCallback& callback) {
   if (scenario_ != TestScenario::LOAD_FAILED) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, true, offline_pages_));
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(callback, false, std::vector<OfflinePageItem>()));
@@ skipping 75 matching lines @@
   void SetUp() override;
   void TearDown() override;
 
   // OfflinePageModel::Observer implementation.
   void OfflinePageModelLoaded(OfflinePageModel* model) override;
 
   // OfflinePageModel callbacks.
   void OnSavePageDone(SavePageResult result);
   void OnDeletePageDone(DeletePageResult result);
 
+  // OfflinePageMetadataStore callbacks.
+  void OnStoreUpdateDone(bool /* success */);
+
   scoped_ptr<OfflinePageTestArchiver> BuildArchiver(
       const GURL& url,
       OfflinePageArchiver::ArchiverResult result);
   scoped_ptr<OfflinePageMetadataStore> BuildStore();
-  scoped_ptr<OfflinePageModel> BuildModel();
+  scoped_ptr<OfflinePageModel> BuildModel(
+      scoped_ptr<OfflinePageMetadataStore> store);
+  void ResetModel();
 
   // Utility methods.
   void PumpLoop();
   void ResetResults();
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner() {
     return message_loop_.task_runner();
   }
 
   OfflinePageModel* model() { return model_.get(); }
@@ skipping 63 matching lines @@
 OfflinePageModelTest::OfflinePageModelTest()
     : last_save_result_(SavePageResult::CANCELLED),
       last_delete_result_(DeletePageResult::CANCELLED) {
 }
 
 OfflinePageModelTest::~OfflinePageModelTest() {
 }
 
 void OfflinePageModelTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-  model_ = BuildModel().Pass();
+  model_ = BuildModel(BuildStore().Pass()).Pass();
   model_->AddObserver(this);
   PumpLoop();
 }
 
 void OfflinePageModelTest::TearDown() {
   model_->RemoveObserver(this);
 }
 
 void OfflinePageModelTest::OfflinePageModelLoaded(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
   run_loop_->Quit();
 }
 
 void OfflinePageModelTest::OnSavePageDone(
     OfflinePageModel::SavePageResult result) {
   run_loop_->Quit();
   last_save_result_ = result;
 }
 
 void OfflinePageModelTest::OnDeletePageDone(DeletePageResult result) {
   run_loop_->Quit();
   last_delete_result_ = result;
 }
 
+void OfflinePageModelTest::OnStoreUpdateDone(bool /* success - ignored */) {
+  run_loop_->Quit();
+}
+
 scoped_ptr<OfflinePageTestArchiver> OfflinePageModelTest::BuildArchiver(
     const GURL& url,
     OfflinePageArchiver::ArchiverResult result) {
   return scoped_ptr<OfflinePageTestArchiver>(new OfflinePageTestArchiver(
       this, url, temp_dir_.path(), result, task_runner()));
 }
 
 scoped_ptr<OfflinePageMetadataStore> OfflinePageModelTest::BuildStore() {
   return scoped_ptr<OfflinePageMetadataStore>(
       new OfflinePageTestStore(task_runner()));
 }
 
-scoped_ptr<OfflinePageModel> OfflinePageModelTest::BuildModel() {
+scoped_ptr<OfflinePageModel> OfflinePageModelTest::BuildModel(
+    scoped_ptr<OfflinePageMetadataStore> store) {
   return scoped_ptr<OfflinePageModel>(
-      new OfflinePageModel(BuildStore().Pass(), task_runner()));
+      new OfflinePageModel(store.Pass(), task_runner()));
+}
+
+void OfflinePageModelTest::ResetModel() {
+  model_->RemoveObserver(this);
+  OfflinePageTestStore* old_store = GetStore();
+  scoped_ptr<OfflinePageMetadataStore> new_store(
+      new OfflinePageTestStore(*old_store));
+  model_ = BuildModel(new_store.Pass()).Pass();
+  model_->AddObserver(this);
+  PumpLoop();
 }
 
 void OfflinePageModelTest::PumpLoop() {
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 }
 
 void OfflinePageModelTest::ResetResults() {
   last_save_result_ = SavePageResult::CANCELLED;
   last_delete_result_ = DeletePageResult::CANCELLED;
@@ skipping 336 matching lines @@
 
   page = model()->GetPageByOfflineURL(offline_url);
   EXPECT_TRUE(page);
   EXPECT_EQ(kTestUrl, page->url);
   EXPECT_EQ(kTestPageBookmarkId1, page->bookmark_id);
 
   page = model()->GetPageByOfflineURL(GURL("http://foo"));
   EXPECT_FALSE(page);
 }
 
+// Test that model returns pages that are older than 30 days as candidates for
+// clean up, hence the numbers in time delta.
+TEST_F(OfflinePageModelTest, GetPagesToCleanUp) {
+  base::Time now = base::Time::Now();
+  OfflinePageItem page_1(
+      GURL(kTestUrl), kTestPageBookmarkId1,
+      base::FilePath(FILE_PATH_LITERAL("/test/location/page1.mhtml")),
+      kTestFileSize, now - base::TimeDelta::FromDays(40));
+  GetStore()->AddOfflinePage(
+      page_1,
+      base::Bind(&OfflinePageModelTest::OnStoreUpdateDone, AsWeakPtr()));
+  PumpLoop();
+
+  OfflinePageItem page_2(
+      GURL(kTestUrl2), kTestPageBookmarkId2,
+      base::FilePath(FILE_PATH_LITERAL("/test/location/page2.mhtml")),
+      kTestFileSize, now - base::TimeDelta::FromDays(31));
+  GetStore()->AddOfflinePage(
+      page_2,
+      base::Bind(&OfflinePageModelTest::OnStoreUpdateDone, AsWeakPtr()));
+  PumpLoop();
+
+  OfflinePageItem page_3(
+      GURL("http://test.xyz"), 42,
+      base::FilePath(FILE_PATH_LITERAL("/test/location/page3.mhtml")),
+      kTestFileSize, now - base::TimeDelta::FromDays(29));
+  GetStore()->AddOfflinePage(
+      page_3,
+      base::Bind(&OfflinePageModelTest::OnStoreUpdateDone, AsWeakPtr()));
+  PumpLoop();
+
+  ResetModel();
+
+  // Only page_1 and page_2 are expected to be picked up by the model as page_3
+  // has not been in the store long enough.
+  std::vector<OfflinePageItem> pages_to_clean_up = model()->GetPagesToCleanUp();
+  EXPECT_EQ(2UL, pages_to_clean_up.size());
+  EXPECT_EQ(kTestUrl, pages_to_clean_up[0].url);
+  EXPECT_EQ(kTestPageBookmarkId1, pages_to_clean_up[0].bookmark_id);
+  EXPECT_EQ(kTestUrl2, pages_to_clean_up[1].url);
+  EXPECT_EQ(kTestPageBookmarkId2, pages_to_clean_up[1].bookmark_id);
+}
+
 }  // namespace offline_pages