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 56 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();
+  const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
+  EXPECT_EQ(1UL, offline_pages.size());
+  EXPECT_EQ(1UL, GetStore()->offline_pages().size());

[fgorski, 2015/10/23 20:55:03]

come on :) have at least 2 items in the store here ;)

[jianli, 2015/10/26 21:42:44]

Done.

+  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> archiver2(
+      BuildArchiver(kTestUrl2,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl2, kTestPageBookmarkId2, archiver2.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+  EXPECT_EQ(1UL, model()->GetAllPages().size());
+  EXPECT_EQ(1UL, GetStore()->offline_pages().size());
+}
+
 }  // namespace offline_pages