[Offline pages] Refactoring helper classes out from offline_page_model_unittest.cc

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/bookmarks/browser/bookmark_node.h"
 #include "components/offline_pages/offline_page_item.h"
-#include "components/offline_pages/offline_page_metadata_store.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;
 
 namespace offline_pages {
 
 namespace {
 const GURL kTestUrl("http://example.com");
 const int64 kTestPageBookmarkId1 = 1234LL;
 const GURL kTestUrl2("http://other.page.com");
 const GURL kTestUrl3("http://test.xyz");
 const GURL kFileUrl("file:///foo");
 const int64 kTestPageBookmarkId2 = 5678LL;
 const int64 kTestPageBookmarkId3 = 42LL;
 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 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_;
-  }
-
- private:
-  OfflinePageItem last_saved_page_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  TestScenario scenario_;
-
-  std::vector<OfflinePageItem> offline_pages_;
-
-  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) {
-  OfflinePageMetadataStore::LoadStatus load_status;
-  if (scenario_ != TestScenario::LOAD_FAILED) {
-    load_status = OfflinePageMetadataStore::LOAD_SUCCEEDED;
-  } else {
-    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));
-}
-
-void OfflinePageTestStore::RemoveOfflinePages(
-    const std::vector<int64>& bookmark_ids,
-    const UpdateCallback& callback) {
-  ASSERT_FALSE(bookmark_ids.empty());
-  bool result = false;
-  if (scenario_ != TestScenario::REMOVE_FAILED) {
-    for (auto iter = offline_pages_.begin();
-         iter != offline_pages_.end(); ++iter) {
-      if (iter->bookmark_id == bookmark_ids[0]) {
-        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;
-    }
-  }
-}
-
 }  // namespace
 
-class OfflinePageModelTest;
-
-class OfflinePageTestArchiver : public OfflinePageArchiver {
- public:
-  OfflinePageTestArchiver(
-      OfflinePageModelTest* test,
-      const GURL& url,
-      ArchiverResult result,
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
-  ~OfflinePageTestArchiver() override;
-
-  // OfflinePageArchiver implementation:
-  void CreateArchive(const base::FilePath& archives_dir,
-                     const CreateArchiveCallback& callback) override;
-
-  void CompleteCreateArchive();
-
-  void set_delayed(bool delayed) { delayed_ = delayed; }
-
-  bool create_archive_called() const { return create_archive_called_; }
-
- private:
-  OfflinePageModelTest* test_;  // Outlive OfflinePageTestArchiver.
-  GURL url_;
-  base::FilePath archives_dir_;
-  ArchiverResult result_;
-  bool create_archive_called_;
-  bool delayed_;
-  CreateArchiveCallback callback_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  DISALLOW_COPY_AND_ASSIGN(OfflinePageTestArchiver);
-};
-
 class OfflinePageModelTest
     : public testing::Test,
       public OfflinePageModel::Observer,
+      public OfflinePageTestArchiver::Observer,
       public base::SupportsWeakPtr<OfflinePageModelTest> {
  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;
 
+  // OfflinePageTestArchiver::Observer implementation.
+  void SetLastPathCreatedByArchiver(const base::FilePath& file_path) 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,
@@ skipping 21 matching lines @@
 
   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_;
   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,
-    ArchiverResult result,
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
-    : test_(test),
-      url_(url),
-      result_(result),
-      create_archive_called_(false),
-      delayed_(false),
-      task_runner_(task_runner) {
-}
-
-OfflinePageTestArchiver::~OfflinePageTestArchiver() {
-  EXPECT_TRUE(create_archive_called_);
-}
-
-void OfflinePageTestArchiver::CreateArchive(
-    const base::FilePath& archives_dir,
-    const CreateArchiveCallback& callback) {
-  create_archive_called_ = true;
-  callback_ = callback;
-  archives_dir_ = archives_dir;
-  if (!delayed_)
-    CompleteCreateArchive();
-}
-
-void OfflinePageTestArchiver::CompleteCreateArchive() {
-  DCHECK(!callback_.is_null());
-  base::FilePath archive_path;
-  ASSERT_TRUE(base::CreateTemporaryFileInDir(archives_dir_, &archive_path));
-  test_->set_last_archiver_path(archive_path);
-  task_runner_->PostTask(FROM_HERE, base::Bind(callback_, this, result_, url_,
-                                               archive_path, kTestFileSize));
-}
-
 OfflinePageModelTest::OfflinePageModelTest()
     : last_save_result_(SavePageResult::CANCELLED),
       last_delete_result_(DeletePageResult::CANCELLED),
       last_deleted_bookmark_id_(-1) {
 }
 
 OfflinePageModelTest::~OfflinePageModelTest() {
 }
 
 void OfflinePageModelTest::SetUp() {
@@ skipping 13 matching lines @@
 }
 
 void OfflinePageModelTest::OfflinePageModelChanged(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
 }
 
 void OfflinePageModelTest::OfflinePageDeleted(int64 bookmark_id) {
   last_deleted_bookmark_id_ = bookmark_id;
 }
 
+void OfflinePageModelTest::SetLastPathCreatedByArchiver(
+    const base::FilePath& file_path) {
+  last_archiver_path_ = file_path;
+}
+
 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, result, task_runner()));
+  return scoped_ptr<OfflinePageTestArchiver>(new OfflinePageTestArchiver(
+      this, url, result, kTestFileSize, task_runner()));
 }
 
 scoped_ptr<OfflinePageMetadataStore> OfflinePageModelTest::BuildStore() {
   return scoped_ptr<OfflinePageMetadataStore>(
       new OfflinePageTestStore(task_runner()));
 }
 
 scoped_ptr<OfflinePageModel> OfflinePageModelTest::BuildModel(
     scoped_ptr<OfflinePageMetadataStore> store) {
   return scoped_ptr<OfflinePageModel>(
@@ skipping 655 matching lines @@
 
   // Chrome should not crash when a bookmark with no offline copy is changed.
   // http://crbug.com/560518
   bookmark_node.set_url(kTestUrl);
   model()->BookmarkNodeChanged(nullptr, &bookmark_node);
   PumpLoop();
   EXPECT_EQ(0UL, model()->GetAllPages().size());
 }
 
 }  // namespace offline_pages