Use ScopedTaskEnvironment instead of MessageLoopForUI in components tests.

components/sync/driver/async_directory_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/async_directory_type_controller.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/tracked_objects.h"
 #include "components/sync/driver/async_directory_type_controller_mock.h"
 #include "components/sync/driver/data_type_controller_mock.h"
 #include "components/sync/driver/fake_sync_client.h"
 #include "components/sync/driver/generic_change_processor_factory.h"
 #include "components/sync/engine/model_safe_worker.h"
 #include "components/sync/model/fake_syncable_service.h"
@@ skipping 141 matching lines @@
   AsyncDirectoryTypeControllerMock* mock_;
   scoped_refptr<SharedChangeProcessor> change_processor_;
   scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncDirectoryTypeControllerFake);
 };
 
 class SyncAsyncDirectoryTypeControllerTest : public testing::Test,
                                              public FakeSyncClient {
  public:
-  SyncAsyncDirectoryTypeControllerTest() : backend_thread_("dbthread") {}
+  SyncAsyncDirectoryTypeControllerTest()
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        backend_thread_("dbthread") {}
 
   void SetUp() override {
     backend_thread_.Start();
     change_processor_ = new SharedChangeProcessorMock(kType);
     // All of these are refcounted, so don't need to be released.
     dtc_mock_ =
         base::MakeUnique<StrictMock<AsyncDirectoryTypeControllerMock>>();
     non_ui_dtc_ = base::MakeUnique<AsyncDirectoryTypeControllerFake>(
         this, dtc_mock_.get(), change_processor_.get(),
         backend_thread_.task_runner());
@@ skipping 55 matching lines @@
 
   void Start() {
     non_ui_dtc_->LoadModels(base::Bind(
         &ModelLoadCallbackMock::Run, base::Unretained(&model_load_callback_)));
     non_ui_dtc_->StartAssociating(base::Bind(
         &StartCallbackMock::Run, base::Unretained(&start_callback_)));
   }
 
   static void SignalDone(WaitableEvent* done) { done->Signal(); }
 
-  base::MessageLoopForUI message_loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::Thread backend_thread_;
 
   StartCallbackMock start_callback_;
   ModelLoadCallbackMock model_load_callback_;
   // Must be destroyed after non_ui_dtc_.
   FakeSyncableService syncable_service_;
   std::unique_ptr<AsyncDirectoryTypeControllerFake> non_ui_dtc_;
   std::unique_ptr<AsyncDirectoryTypeControllerMock> dtc_mock_;
   scoped_refptr<SharedChangeProcessorMock> change_processor_;
   std::unique_ptr<SyncChangeProcessor> saved_change_processor_;
@@ skipping 202 matching lines @@
   backend_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&DataTypeErrorHandler::OnUnrecoverableError,
                  base::Passed(non_ui_dtc_->CreateErrorHandler()), error));
   WaitForDTC();
 }
 
 }  // namespace
 
 }  // namespace syncer