[Offline pages] Detecting missing offline copy

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 155 matching lines @@
  public:
   OfflinePageModelTest();
   ~OfflinePageModelTest() override;
 
   void SetUp() override;
   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);
 
   // OfflinePageMetadataStore callbacks.
   void OnStoreUpdateDone(bool /* success */);
 
   scoped_ptr<OfflinePageTestArchiver> BuildArchiver(
       const GURL& url,
@@ skipping 16 matching lines @@
   OfflinePageTestStore* GetStore();
 
   SavePageResult last_save_result() const {
     return last_save_result_;
   }
 
   DeletePageResult last_delete_result() const {
     return last_delete_result_;
   }
 
+  int64 last_deleted_bookmark_id() const {
+    return last_deleted_bookmark_id_;
+  }
+
   const base::FilePath& last_archiver_path() { return last_archiver_path_; }
   void set_last_archiver_path(const base::FilePath& last_archiver_path) {
     last_archiver_path_ = last_archiver_path;
   }
 
  private:
   base::MessageLoop message_loop_;
   scoped_ptr<base::RunLoop> run_loop_;
   base::ScopedTempDir temp_dir_;
 
   scoped_ptr<OfflinePageModel> model_;
   SavePageResult last_save_result_;
   DeletePageResult last_delete_result_;
   base::FilePath last_archiver_path_;
+  int64 last_deleted_bookmark_id_;
 };
 
 OfflinePageTestArchiver::OfflinePageTestArchiver(
     OfflinePageModelTest* test,
     const GURL& url,
     const base::FilePath& archiver_dir,
     ArchiverResult result,
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : test_(test),
       url_(url),
@@ skipping 20 matching lines @@
   DCHECK(!callback_.is_null());
   base::FilePath archiver_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(archiver_dir_, &archiver_path));
   test_->set_last_archiver_path(archiver_path);
   task_runner_->PostTask(FROM_HERE, base::Bind(callback_, this, result_, url_,
                                                archiver_path, kTestFileSize));
 }
 
 OfflinePageModelTest::OfflinePageModelTest()
     : last_save_result_(SavePageResult::CANCELLED),
-      last_delete_result_(DeletePageResult::CANCELLED) {
+      last_delete_result_(DeletePageResult::CANCELLED),
+      last_deleted_bookmark_id_(-1) {
 }
 
 OfflinePageModelTest::~OfflinePageModelTest() {
 }
 
 void OfflinePageModelTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   model_ = BuildModel(BuildStore().Pass()).Pass();
   model_->AddObserver(this);
   PumpLoop();
 }
 
 void OfflinePageModelTest::TearDown() {
   model_->RemoveObserver(this);
+  base::RunLoop().RunUntilIdle();
 }
 
 void OfflinePageModelTest::OfflinePageModelLoaded(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
   run_loop_->Quit();
 }
 
 void OfflinePageModelTest::OfflinePageModelChanged(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
 }
 
+void OfflinePageModelTest::OfflinePageDeleted(int64 bookmark_id) {
+  last_deleted_bookmark_id_ = bookmark_id;
+  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;
 }
@@ skipping 365 matching lines @@
   // Try to delete this page.
   GetStore()->set_test_scenario(
       OfflinePageTestStore::TestScenario::REMOVE_FAILED);
   model()->DeletePageByBookmarkId(
       kTestPageBookmarkId1, base::Bind(&OfflinePageModelTest::OnDeletePageDone,
                                        AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(DeletePageResult::STORE_FAILURE, last_delete_result());
 }
 
+TEST_F(OfflinePageModelTest, DetectThatOfflineCopyIsMissing) {
+  // Save a page.
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+
+  ResetResults();
+
+  const OfflinePageItem* page =
+      model()->GetPageByBookmarkId(kTestPageBookmarkId1);
+  // Delete the offline copy of the page and check the metadata.
+  base::DeleteFile(page->file_path, false);
+  model()->CheckForExternalFileDeletion();
+  PumpLoop();
+
+  EXPECT_EQ(last_deleted_bookmark_id(), kTestPageBookmarkId1);
+  EXPECT_EQ(0UL, model()->GetAllPages().size());
+}
+
+TEST_F(OfflinePageModelTest, DetectThatOfflineCopyIsMissingAfterLoad) {
+  // Save a page.
+  scoped_ptr<OfflinePageTestArchiver> archiver(
+      BuildArchiver(kTestUrl,
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
+          .Pass());
+  model()->SavePage(
+      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
+  PumpLoop();
+
+  ResetResults();
+
+  const OfflinePageItem* page =
+      model()->GetPageByBookmarkId(kTestPageBookmarkId1);
+  // Delete the offline copy of the page and check the metadata.
+  base::DeleteFile(page->file_path, false);
+  // Reseting the model should trigger the metadata consistency check as well.
+  ResetModel();
+  PumpLoop();
+
+  EXPECT_EQ(last_deleted_bookmark_id(), kTestPageBookmarkId1);
+  EXPECT_EQ(0UL, model()->GetAllPages().size());
+}
+
 TEST_F(OfflinePageModelTest, GetPageByBookmarkId) {
   scoped_ptr<OfflinePageTestArchiver> archiver(
       BuildArchiver(kTestUrl,
                     OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
           .Pass());
   model()->SavePage(
       kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
@@ skipping 101 matching lines @@
   // 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