Use ScopedTaskEnvironment instead of MessageLoopForUI in components tests.

components/sync/driver/generic_change_processor_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/generic_change_processor.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/scoped_task_environment.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/device_info/local_device_info_provider.h"
 #include "components/sync/driver/fake_sync_client.h"
 #include "components/sync/driver/sync_api_component_factory.h"
 #include "components/sync/engine/attachments/fake_attachment_downloader.h"
 #include "components/sync/engine/attachments/fake_attachment_uploader.h"
 #include "components/sync/engine/sync_encryption_handler.h"
 #include "components/sync/model/attachments/attachment_id.h"
 #include "components/sync/model/data_type_error_handler_mock.h"
 #include "components/sync/model/fake_syncable_service.h"
@@ skipping 91 matching lines @@
   MockAttachmentService* mock_attachment_service_;
 };
 
 class SyncGenericChangeProcessorTest : public testing::Test {
  public:
   // Most test cases will use this type.  For those that need a
   // GenericChangeProcessor for a different type, use |InitializeForType|.
   static const ModelType kType = PREFERENCES;
 
   SyncGenericChangeProcessorTest()
-      : syncable_service_ptr_factory_(&fake_syncable_service_),
+      : scoped_task_environment_(
+            base::test::ScopedTaskEnvironment::MainThreadType::UI),
+        syncable_service_ptr_factory_(&fake_syncable_service_),
         mock_attachment_service_(nullptr),
         sync_client_(&sync_factory_) {}
 
   void SetUp() override {
     // Use kType by default, but allow test cases to re-initialize with whatever
     // type they choose.  Therefore, it's important that all type dependent
     // initialization occurs in InitializeForType.
     InitializeForType(kType);
   }
 
@@ skipping 49 matching lines @@
   MockAttachmentService* mock_attachment_service() {
     return mock_attachment_service_;
   }
 
   void RunLoop() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
  private:
-  base::MessageLoopForUI loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
 
   std::unique_ptr<SyncMergeResult> sync_merge_result_;
   std::unique_ptr<base::WeakPtrFactory<SyncMergeResult>>
       merge_result_ptr_factory_;
 
   FakeSyncableService fake_syncable_service_;
   base::WeakPtrFactory<FakeSyncableService> syncable_service_ptr_factory_;
 
   std::unique_ptr<TestUserShare> test_user_share_;
   MockAttachmentService* mock_attachment_service_;
@@ skipping 294 matching lines @@
   SyncDataList sync_data = change_processor()->GetAllSyncData(SESSIONS);
   ASSERT_EQ(sync_data.size(), 1U);
   ASSERT_EQ("session tag 2",
             sync_data[0].GetSpecifics().session().session_tag());
   EXPECT_FALSE(SyncDataRemote(sync_data[0]).GetClientTagHash().empty());
 }
 
 }  // namespace
 
 }  // namespace syncer