[Sync] Move sync thread ownership to ProfileSyncService.

components/sync/driver/glue/sync_backend_registrar_unittest.cc

 // Copyright 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.
 
 #include "components/sync/driver/glue/sync_backend_registrar.h"
 
 #include <memory>
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
@@ skipping 62 matching lines @@
     registrar_->ActivateDataType(AUTOFILL, GROUP_DB, processor,
                                  test_user_share_.user_share());
     ExpectRoutingInfo(registrar_.get(), {{AUTOFILL, GROUP_DB}});
     ExpectHasProcessorsForTypes(*registrar_, ModelTypeSet(AUTOFILL));
     TriggerChanges(registrar_.get(), AUTOFILL);
     done->Signal();
   }
 
  protected:
   SyncBackendRegistrarTest()
-      : db_thread_("DBThreadForTest"), file_thread_("FileThreadForTest") {}
+      : db_thread_("DBThreadForTest"),
+        file_thread_("FileThreadForTest"),
+        sync_thread_("SyncThreadForTest") {}
 
   ~SyncBackendRegistrarTest() override {}
 
   void SetUp() override {
     db_thread_.StartAndWaitForTesting();
     file_thread_.StartAndWaitForTesting();
+    sync_thread_.StartAndWaitForTesting();
     test_user_share_.SetUp();
     sync_client_ = base::MakeUnique<RegistrarSyncClient>(
         ui_task_runner(), db_task_runner(), file_task_runner());
     registrar_ = base::MakeUnique<SyncBackendRegistrar>(
-        "test", sync_client_.get(), std::unique_ptr<base::Thread>(),
-        ui_task_runner(), db_task_runner(), file_task_runner());
+        "test", sync_client_.get(), ui_task_runner(), db_task_runner(),
+        file_task_runner());
   }
 
   void TearDown() override {
     registrar_->RequestWorkerStopOnUIThread();
     test_user_share_.TearDown();
-    {
-      std::unique_ptr<base::Thread> released_sync_thread =
-          registrar_->ReleaseSyncThread();
-      released_sync_thread->task_runner()->DeleteSoon(FROM_HERE,
-                                                      registrar_.release());
-      // |released_sync_thread| is joined at the end of this scope.
-    }
-    base::RunLoop().RunUntilIdle();
+    sync_thread_.task_runner()->DeleteSoon(FROM_HERE, registrar_.release());
+    sync_thread_.FlushForTesting();
   }
 
   void ExpectRoutingInfo(SyncBackendRegistrar* registrar,
                          const ModelSafeRoutingInfo& expected_routing_info) {
     ModelSafeRoutingInfo actual_routing_info;
     registrar->GetModelSafeRoutingInfo(&actual_routing_info);
     EXPECT_EQ(expected_routing_info, actual_routing_info);
   }
 
   void ExpectHasProcessorsForTypes(const SyncBackendRegistrar& registrar,
@@ skipping 19 matching lines @@
     return db_thread_.task_runner();
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner> file_task_runner() {
     return db_thread_.task_runner();
   }
 
   base::MessageLoop message_loop_;
   base::Thread db_thread_;
   base::Thread file_thread_;
+  base::Thread sync_thread_;
 
   TestUserShare test_user_share_;
   std::unique_ptr<RegistrarSyncClient> sync_client_;
   std::unique_ptr<SyncBackendRegistrar> registrar_;
 };
 
 TEST_F(SyncBackendRegistrarTest, ConstructorEmpty) {
   registrar_->SetInitialTypes(ModelTypeSet());
   EXPECT_FALSE(registrar_->IsNigoriEnabled());
   EXPECT_EQ(4u, GetWorkersSize());
@@ skipping 141 matching lines @@
       registrar_->ConfigureDataTypes(types_to_add, ModelTypeSet());
   EXPECT_EQ(ModelTypeSet(BOOKMARKS), newly_added_types);
   EXPECT_EQ(types_to_add, registrar_->GetLastConfiguredTypes());
   ExpectRoutingInfo(registrar_.get(), {{AUTOFILL, GROUP_NON_BLOCKING},
                                        {BOOKMARKS, GROUP_NON_BLOCKING}});
 }
 
 }  // namespace
 
 }  // namespace syncer