components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/sync_driver/non_ui_data_type_controller_unittest.cc

 // Copyright 2014 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/sync_driver/non_ui_data_type_controller.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
 #include "components/sync_driver/data_type_controller_mock.h"
 #include "components/sync_driver/generic_change_processor_factory.h"
 #include "components/sync_driver/non_ui_data_type_controller_mock.h"
 #include "sync/api/fake_syncable_service.h"
 #include "sync/api/sync_change.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 64 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SharedChangeProcessorMock);
 };
 
 class NonUIDataTypeControllerFake
     : public NonUIDataTypeController {
  public:
   NonUIDataTypeControllerFake(
       SyncApiComponentFactory* sync_factory,
       NonUIDataTypeControllerMock* mock,
       SharedChangeProcessor* change_processor,
-      scoped_refptr<base::MessageLoopProxy> backend_loop)
-      : NonUIDataTypeController(
-          base::MessageLoopProxy::current(),
-          base::Closure(),
-          sync_factory),
+      scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner)
+      : NonUIDataTypeController(base::ThreadTaskRunnerHandle::Get(),
+                                base::Closure(),
+                                sync_factory),
         blocked_(false),
         mock_(mock),
         change_processor_(change_processor),
-        backend_loop_(backend_loop) {}
+        backend_task_runner_(backend_task_runner) {}
 
   syncer::ModelType type() const override { return AUTOFILL_PROFILE; }
   syncer::ModelSafeGroup model_safe_group() const override {
     return syncer::GROUP_DB;
   }
 
   // Prevent tasks from being posted on the backend thread until
   // UnblockBackendTasks() is called.
   void BlockBackendTasks() {
     blocked_ = true;
@@ skipping 14 matching lines @@
     return change_processor_.get();
   }
 
  protected:
   bool PostTaskOnBackendThread(const tracked_objects::Location& from_here,
                                const base::Closure& task) override {
     if (blocked_) {
       pending_tasks_.push_back(PendingTask(from_here, task));
       return true;
     } else {
-      return backend_loop_->PostTask(from_here, task);
+      return backend_task_runner_->PostTask(from_here, task);
     }
   }
 
   // We mock the following methods because their default implementations do
   // nothing, but we still want to make sure they're called appropriately.
   bool StartModels() override { return mock_->StartModels(); }
   void StopModels() override { mock_->StopModels(); }
   void RecordAssociationTime(base::TimeDelta time) override {
     mock_->RecordAssociationTime(time);
   }
@@ skipping 12 matching lines @@
         : from_here(from_here), task(task) {}
 
     tracked_objects::Location from_here;
     base::Closure task;
   };
 
   bool blocked_;
   std::vector<PendingTask> pending_tasks_;
   NonUIDataTypeControllerMock* mock_;
   scoped_refptr<SharedChangeProcessor> change_processor_;
-  scoped_refptr<base::MessageLoopProxy> backend_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
 };
 
 class SyncNonUIDataTypeControllerTest : public testing::Test {
  public:
   SyncNonUIDataTypeControllerTest()
       : backend_thread_("dbthread") {}
 
   void SetUp() override {
     backend_thread_.Start();
     change_processor_ = new SharedChangeProcessorMock();
     // All of these are refcounted, so don't need to be released.
     dtc_mock_ = new StrictMock<NonUIDataTypeControllerMock>();
-    non_ui_dtc_ =
-        new NonUIDataTypeControllerFake(NULL,
-                                        dtc_mock_.get(),
-                                        change_processor_.get(),
-                                        backend_thread_.message_loop_proxy());
+    non_ui_dtc_ = new NonUIDataTypeControllerFake(
+        NULL, dtc_mock_.get(), change_processor_.get(),
+        backend_thread_.task_runner());
   }
 
   void TearDown() override { backend_thread_.Stop(); }
 
   void WaitForDTC() {
     WaitableEvent done(true, false);
-    backend_thread_.message_loop_proxy()->PostTask(
-       FROM_HERE,
-       base::Bind(&SyncNonUIDataTypeControllerTest::SignalDone,
-                  &done));
+    backend_thread_.task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&SyncNonUIDataTypeControllerTest::SignalDone, &done));
     done.TimedWait(TestTimeouts::action_timeout());
     if (!done.IsSignaled()) {
       ADD_FAILURE() << "Timed out waiting for DB thread to finish.";
     }
     base::MessageLoop::current()->RunUntilIdle();
   }
 
  protected:
   void SetStartExpectations() {
     EXPECT_CALL(*dtc_mock_.get(), StartModels()).WillOnce(Return(true));
@@ skipping 261 matching lines @@
   Start();
   WaitForDTC();
   EXPECT_EQ(DataTypeController::RUNNING, non_ui_dtc_->state());
 
   testing::Mock::VerifyAndClearExpectations(&start_callback_);
   EXPECT_CALL(model_load_callback_, Run(_, _));
   syncer::SyncError error(FROM_HERE,
                           syncer::SyncError::DATATYPE_ERROR,
                           "error",
                           non_ui_dtc_->type());
-  backend_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
-      &NonUIDataTypeControllerFake::
-          OnSingleDataTypeUnrecoverableError,
-      non_ui_dtc_.get(),
-      error));
+  backend_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &NonUIDataTypeControllerFake::OnSingleDataTypeUnrecoverableError,
+          non_ui_dtc_.get(), error));
   WaitForDTC();
 }
 
 }  // namespace
 
 }  // namespace sync_driver