components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/history/core/browser/history_service_unittest.cc

 // Copyright (c) 2012 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.
 
 // History unit tests come in two flavors:
 //
 // 1. The more complicated style is that the unit test creates a full history
 //    service. This spawns a background thread for the history backend, and
 //    all communication is asynchronous. This is useful for testing more
 //    complicated things or end-to-end behavior.
 //
 // 2. The simpler style is to create a history backend on this thread and
 //    access it directly without a HistoryService object. This is much simpler
 //    because communication is synchronous. Generally, sets should go through
 //    the history backend (since there is a lot of logic) but gets can come
 //    directly from the HistoryDatabase. This is because the backend generally
 //    has no logic in the getter except threading stuff, which we don't want
 //    to run.
 
 #include "components/history/core/browser/history_service.h"
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/location.h"
 #include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/test/database_test_utils.h"
 #include "components/history/core/test/test_history_database.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_change_processor_wrapper_for_test.h"
 #include "sync/api/sync_error.h"
@@ skipping 32 matching lines @@
       ADD_FAILURE();
     }
   }
 
   void TearDown() override {
     if (history_service_)
       CleanupHistoryService();
 
     // Make sure we don't have any event pending that could disrupt the next
     // test.
-    base::MessageLoop::current()->PostTask(FROM_HERE,
-                                           base::MessageLoop::QuitClosure());
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
   }
 
   void CleanupHistoryService() {
     DCHECK(history_service_);
 
     history_service_->ClearCachedDataForContextID(0);
     history_service_->SetOnBackendDestroyTask(base::MessageLoop::QuitClosure());
     history_service_->Cleanup();
     history_service_.reset();
@@ skipping 581 matching lines @@
 void CheckDirectiveProcessingResult(
     base::Time timeout,
     const syncer::FakeSyncChangeProcessor* change_processor,
     uint32 num_changes) {
   if (base::Time::Now() > timeout ||
       change_processor->changes().size() >= num_changes) {
     return;
   }
 
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&CheckDirectiveProcessingResult, timeout,
-                 change_processor, num_changes));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&CheckDirectiveProcessingResult, timeout,
+                            change_processor, num_changes));
 }
 
 // Create a delete directive for a few specific history entries,
 // including ones that don't exist. The expected entries should be
 // deleted.
 TEST_F(HistoryServiceTest, ProcessGlobalIdDeleteDirective) {
   ASSERT_TRUE(history_service_.get());
   const GURL test_url("http://www.google.com/");
   for (int64 i = 1; i <= 20; i++) {
     base::Time t =
@@ skipping 46 matching lines @@
                             directives,
                             scoped_ptr<syncer::SyncChangeProcessor>(
                                 new syncer::SyncChangeProcessorWrapperForTest(
                                     &change_processor)),
                             scoped_ptr<syncer::SyncErrorFactory>())
           .error()
           .IsSet());
 
   // Inject a task to check status and keep message loop filled before directive
   // processing finishes.
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult,
                  base::Time::Now() + base::TimeDelta::FromSeconds(10),
                  &change_processor, 2));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   ASSERT_EQ(5, query_url_row_.visit_count());
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1),
             query_url_visits_[0].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(2),
@@ skipping 64 matching lines @@
                             directives,
                             scoped_ptr<syncer::SyncChangeProcessor>(
                                 new syncer::SyncChangeProcessorWrapperForTest(
                                     &change_processor)),
                             scoped_ptr<syncer::SyncErrorFactory>())
           .error()
           .IsSet());
 
   // Inject a task to check status and keep message loop filled before
   // directive processing finishes.
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&CheckDirectiveProcessingResult,
                  base::Time::Now() + base::TimeDelta::FromSeconds(10),
                  &change_processor, 2));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_TRUE(QueryURL(history_service_.get(), test_url));
   ASSERT_EQ(3, query_url_row_.visit_count());
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(1),
             query_url_visits_[0].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(6),
             query_url_visits_[1].visit_time);
   EXPECT_EQ(base::Time::UnixEpoch() + base::TimeDelta::FromMicroseconds(7),
             query_url_visits_[2].visit_time);
 
   // Expect two sync changes for deleting processed directives.
   const syncer::SyncChangeList& sync_changes = change_processor.changes();
   ASSERT_EQ(2u, sync_changes.size());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[0].change_type());
   EXPECT_EQ(1, syncer::SyncDataRemote(sync_changes[0].sync_data()).GetId());
   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, sync_changes[1].change_type());
   EXPECT_EQ(2, syncer::SyncDataRemote(sync_changes[1].sync_data()).GetId());
 }
 
 }  // namespace history