components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/sync_driver/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/ui_data_type_controller.h"
 
 #include "base/bind.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/thread_task_runner_handle.h"
 #include "base/tracked_objects.h"
 #include "components/sync_driver/data_type_controller_mock.h"
 #include "components/sync_driver/fake_generic_change_processor.h"
 #include "sync/api/fake_syncable_service.h"
 #include "sync/internal_api/public/attachments/attachment_service_impl.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 
 namespace sync_driver {
 namespace {
 
 // TODO(zea): Expand this to make the dtc type paramterizable. This will let us
 // test the basic functionality of all UIDataTypeControllers. We'll need to have
 // intelligent default values for the methods queried in the dependent services
 // (e.g. those queried in StartModels).
 class SyncUIDataTypeControllerTest : public testing::Test,
                                      public SyncApiComponentFactory {
  public:
   SyncUIDataTypeControllerTest()
       : type_(syncer::PREFERENCES),
         change_processor_(NULL) {}
 
   void SetUp() override {
-    preference_dtc_ =
-        new UIDataTypeController(
-            base::MessageLoopProxy::current(),
-            base::Closure(),
-            type_,
-            this);
+    preference_dtc_ = new UIDataTypeController(
+        base::ThreadTaskRunnerHandle::Get(), base::Closure(), type_, this);
     SetStartExpectations();
   }
 
   void TearDown() override {
     // Must be done before we pump the loop.
     syncable_service_.StopSyncing(type_);
     preference_dtc_ = NULL;
     PumpLoop();
   }
 
@@ skipping 71 matching lines @@
   preference_dtc_->Stop();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
   EXPECT_FALSE(syncable_service_.syncing());
 }
 
 // Start and then stop the DTC before the Start had a chance to perform
 // association. Verify that the service never started and is NOT_RUNNING.
 TEST_F(SyncUIDataTypeControllerTest, StartStopBeforeAssociation) {
   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
   EXPECT_FALSE(syncable_service_.syncing());
-  message_loop_.PostTask(FROM_HERE,
-                         base::Bind(&UIDataTypeController::Stop,
-                                    preference_dtc_));
+  message_loop_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&UIDataTypeController::Stop, preference_dtc_));
   Start();
   EXPECT_EQ(DataTypeController::NOT_RUNNING, preference_dtc_->state());
   EXPECT_FALSE(syncable_service_.syncing());
 }
 
 // Start the DTC when no user nodes are created. Verify that the callback
 // is called with OK_FIRST_RUN. Stop the DTC.
 TEST_F(SyncUIDataTypeControllerTest, StartStopFirstRun) {
   EXPECT_CALL(start_callback_, Run(DataTypeController::OK_FIRST_RUN, _, _));
   change_processor_->set_sync_model_has_user_created_nodes(false);
@@ skipping 60 matching lines @@
   EXPECT_CALL(model_load_callback_, Run(_, _));
   syncer::SyncError error(FROM_HERE,
                           syncer::SyncError::DATATYPE_ERROR,
                           "error",
                           syncer::PREFERENCES);
   preference_dtc_->OnSingleDataTypeUnrecoverableError(error);
 }
 
 }  // namespace
 }  // namespace sync_driver