Wipe out offline page data on clearing cookie and site data

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"
@@ skipping 37 matching lines @@
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
   explicit OfflinePageTestStore(const OfflinePageTestStore& other_store);
   ~OfflinePageTestStore() override;
 
   // OfflinePageMetadataStore overrides:
   void Load(const LoadCallback& callback) override;
   void AddOrUpdateOfflinePage(const OfflinePageItem& offline_page,
                               const UpdateCallback& callback) override;
   void RemoveOfflinePages(const std::vector<int64>& bookmark_ids,
                           const UpdateCallback& callback) override;
+  void Reset(const ResetCallback& callback) override;
 
   void UpdateLastAccessTime(int64 bookmark_id,
                             const base::Time& last_access_time);
 
   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_;
@@ skipping 18 matching lines @@
 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) {
+  OfflinePageMetadataStore::LoadStatus load_status;
   if (scenario_ != TestScenario::LOAD_FAILED) {
-    task_runner_->PostTask(
-        FROM_HERE, base::Bind(callback, true, offline_pages_));
+    load_status = OfflinePageMetadataStore::LOAD_SUCCEEDED;
   } else {
-    task_runner_->PostTask(
-        FROM_HERE, base::Bind(callback, false, std::vector<OfflinePageItem>()));
+    load_status = OfflinePageMetadataStore::STORE_LOAD_FAILED;
+    offline_pages_.clear();
   }
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(callback, load_status, offline_pages_));
 }
 
 void OfflinePageTestStore::AddOrUpdateOfflinePage(
     const OfflinePageItem& offline_page, const UpdateCallback& callback) {
   last_saved_page_ = offline_page;
   bool result = scenario_ != TestScenario::WRITE_FAILED;
   if (result) {
     offline_pages_.push_back(offline_page);
   }
   task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
@@ skipping 11 matching lines @@
         offline_pages_.erase(iter);
         result = true;
         break;
       }
     }
   }
 
   task_runner_->PostTask(FROM_HERE, base::Bind(callback, result));
 }
 
+void OfflinePageTestStore::Reset(const ResetCallback& callback) {
+  offline_pages_.clear();
+  task_runner_->PostTask(FROM_HERE, base::Bind(callback, true));
+}
+
 void OfflinePageTestStore:: UpdateLastAccessTime(
     int64 bookmark_id, const base::Time& last_access_time) {
   for (auto& offline_page : offline_pages_) {
     if (offline_page.bookmark_id == bookmark_id) {
       offline_page.last_access_time = last_access_time;
       return;
     }
   }
 }
 
@@ skipping 44 matching lines @@
   void TearDown() override;
 
   // OfflinePageModel::Observer implementation.
   void OfflinePageModelLoaded(OfflinePageModel* model) override;
   void OfflinePageModelChanged(OfflinePageModel* model) override;
   void OfflinePageDeleted(int64 bookmark_id) override;
 
   // OfflinePageModel callbacks.
   void OnSavePageDone(SavePageResult result);
   void OnDeletePageDone(DeletePageResult result);
+  void OnClearAllDone();
 
   // 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<OfflinePageMetadataStore> store);
@@ skipping 110 matching lines @@
 
 void OfflinePageModelTest::OnSavePageDone(
     OfflinePageModel::SavePageResult result) {
   last_save_result_ = result;
 }
 
 void OfflinePageModelTest::OnDeletePageDone(DeletePageResult result) {
   last_delete_result_ = result;
 }
 
+void OfflinePageModelTest::OnClearAllDone() {
+  base::RunLoop().RunUntilIdle();
+}
+
 void OfflinePageModelTest::OnStoreUpdateDone(bool /* success - ignored */) {
 }
 
 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()));
 }
 
@@ skipping 543 matching lines @@
 
 TEST_F(OfflinePageModelTest, CanSavePage) {
   EXPECT_TRUE(OfflinePageModel::CanSavePage(GURL("http://foo")));
   EXPECT_TRUE(OfflinePageModel::CanSavePage(GURL("https://foo")));
   EXPECT_FALSE(OfflinePageModel::CanSavePage(GURL("file:///foo")));
   EXPECT_FALSE(OfflinePageModel::CanSavePage(GURL("data:image/png;base64,ab")));
   EXPECT_FALSE(OfflinePageModel::CanSavePage(GURL("chrome://version")));
   EXPECT_FALSE(OfflinePageModel::CanSavePage(GURL("chrome-native://newtab/")));
 }
 
+TEST_F(OfflinePageModelTest, ClearAll) {
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+
+  scoped_ptr<OfflinePageTestArchiver> archiver2(
+      BuildArchiver(kTestUrl2,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl2, kTestPageBookmarkId2, archiver2.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+
+  const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
+  EXPECT_EQ(2UL, offline_pages.size());
+  EXPECT_EQ(2UL, GetStore()->offline_pages().size());
+  base::FilePath archiver_path = offline_pages[0].file_path;
+  EXPECT_TRUE(base::PathExists(archiver_path));
+
+  // ClearAll should delete all the files and wipe out both cache and store.
+  model()->ClearAll(
+      base::Bind(&OfflinePageModelTest::OnClearAllDone, AsWeakPtr()));
+  PumpLoop();
+  EXPECT_EQ(0UL, model()->GetAllPages().size());
+  EXPECT_EQ(0UL, GetStore()->offline_pages().size());
+  EXPECT_FALSE(base::PathExists(archiver_path));
+
+  // The model should reload the store after the reset. All model operations
+  // should continue to work.
+  scoped_ptr<OfflinePageTestArchiver> archiver3(
+      BuildArchiver(kTestUrl2,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl2, kTestPageBookmarkId2, archiver3.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+  EXPECT_EQ(1UL, model()->GetAllPages().size());
+  EXPECT_EQ(1UL, GetStore()->offline_pages().size());
+}
+
 }  // namespace offline_pages