[Offline pages] Remove references to MessageLoop from components/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/test/test_mock_time_task_runner.h"
+#include "base/thread_task_runner_handle.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_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;
@@ skipping 42 matching lines @@
 
   scoped_ptr<OfflinePageTestArchiver> BuildArchiver(
       const GURL& url,
       OfflinePageArchiver::ArchiverResult result);
   scoped_ptr<OfflinePageMetadataStore> BuildStore();
   scoped_ptr<OfflinePageModel> BuildModel(
       scoped_ptr<OfflinePageMetadataStore> store);
   void ResetModel();
 
   // Utility methods.
+  // Runs until all of the tasks that are not delayed are gone from the task
+  // queue.
   void PumpLoop();
   void ResetResults();
 
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner() {
-    return message_loop_.task_runner();
-  }
-
   OfflinePageModel* model() { return model_.get(); }
 
   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_; }
 
  private:
-  base::MessageLoop message_loop_;
+  scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
+  base::ThreadTaskRunnerHandle task_runner_handle_;
   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_;
 };
 
 OfflinePageModelTest::OfflinePageModelTest()
-    : last_save_result_(SavePageResult::CANCELLED),
+    : task_runner_(new base::TestMockTimeTaskRunner),
+      task_runner_handle_(task_runner_),
+      last_save_result_(SavePageResult::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);
-  base::RunLoop().RunUntilIdle();
+  PumpLoop();
 }
 
 void OfflinePageModelTest::TearDown() {
   model_->RemoveObserver(this);
-  base::RunLoop().RunUntilIdle();
+  PumpLoop();
 }
 
 void OfflinePageModelTest::OfflinePageModelLoaded(OfflinePageModel* model) {
   ASSERT_EQ(model_.get(), model);
 }
 
 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();
+  PumpLoop();
 }
 
 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, kTestFileSize, task_runner()));
+      this, url, result, kTestFileSize, base::ThreadTaskRunnerHandle::Get()));
 }
 
 scoped_ptr<OfflinePageMetadataStore> OfflinePageModelTest::BuildStore() {
   return scoped_ptr<OfflinePageMetadataStore>(
-      new OfflinePageTestStore(task_runner()));
+      new OfflinePageTestStore(base::ThreadTaskRunnerHandle::Get()));
 }
 
 scoped_ptr<OfflinePageModel> OfflinePageModelTest::BuildModel(
     scoped_ptr<OfflinePageMetadataStore> store) {
-  return scoped_ptr<OfflinePageModel>(
-      new OfflinePageModel(store.Pass(), temp_dir_.path(), task_runner()));
+  return scoped_ptr<OfflinePageModel>(new OfflinePageModel(
+      store.Pass(), temp_dir_.path(), base::ThreadTaskRunnerHandle::Get()));
 }
 
 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() {
-  base::RunLoop().RunUntilIdle();
+  task_runner_->RunUntilIdle();
 }
 
 void OfflinePageModelTest::ResetResults() {
   last_save_result_ = SavePageResult::CANCELLED;
   last_delete_result_ = DeletePageResult::CANCELLED;
   last_archiver_path_.clear();
 }
 
 OfflinePageTestStore* OfflinePageModelTest::GetStore() {
   return static_cast<OfflinePageTestStore*>(model()->GetStoreForTesting());
@@ skipping 12 matching lines @@
   EXPECT_TRUE(model()->HasOfflinePages());
 
   OfflinePageTestStore* store = GetStore();
   EXPECT_EQ(kTestUrl, store->last_saved_page().url);
   EXPECT_EQ(kTestPageBookmarkId1, store->last_saved_page().bookmark_id);
   // Save last_archiver_path since it will be referred to later.
   base::FilePath archiver_path = last_archiver_path();
   EXPECT_EQ(archiver_path, store->last_saved_page().file_path);
   EXPECT_EQ(kTestFileSize, store->last_saved_page().file_size);
   EXPECT_EQ(SavePageResult::SUCCESS, last_save_result());
-
   ResetResults();
 
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
 
   EXPECT_EQ(1UL, offline_pages.size());
   EXPECT_EQ(kTestUrl, offline_pages[0].url);
   EXPECT_EQ(kTestPageBookmarkId1, offline_pages[0].bookmark_id);
   EXPECT_EQ(archiver_path, offline_pages[0].file_path);
   EXPECT_EQ(kTestFileSize, offline_pages[0].file_size);
   EXPECT_EQ(0, offline_pages[0].access_count);
@@ skipping 154 matching lines @@
       BuildArchiver(kTestUrl,
                     OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
           .Pass());
   model()->SavePage(
       kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   // This will increase access_count by one.
   model()->MarkPageAccessed(kTestPageBookmarkId1);
-  base::RunLoop().RunUntilIdle();
+  PumpLoop();
 
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
 
   EXPECT_EQ(1UL, offline_pages.size());
   EXPECT_EQ(kTestUrl, offline_pages[0].url);
   EXPECT_EQ(kTestPageBookmarkId1, offline_pages[0].bookmark_id);
   EXPECT_EQ(kTestFileSize, offline_pages[0].file_size);
   EXPECT_EQ(1, offline_pages[0].access_count);
 }
 
@@ skipping 19 matching lines @@
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
   EXPECT_EQ(0UL, offline_pages.size());
 
   EXPECT_FALSE(model()->HasOfflinePages());
   EXPECT_EQ(nullptr, model()->GetPageByOnlineURL(kTestUrl));
   EXPECT_EQ(nullptr, model()->GetPageByBookmarkId(kTestPageBookmarkId1));
   EXPECT_EQ(nullptr, model()->GetPageByOfflineURL(offline_url));
 
   // Undo the deletion.
   model()->UndoPageDeletion(kTestPageBookmarkId1);
-  base::RunLoop().RunUntilIdle();
+  PumpLoop();
 
   // GetAllPages will now return the restored page.
   const std::vector<OfflinePageItem>& offline_pages_after_undo =
       model()->GetAllPages();
   EXPECT_EQ(1UL, offline_pages_after_undo.size());
 }
 
 TEST_F(OfflinePageModelTest, GetAllPagesStoreEmpty) {
   const std::vector<OfflinePageItem>& offline_pages = model()->GetAllPages();
 
@@ skipping 382 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