[Sync] Move sync thread ownership to ProfileSyncService.

components/browser_sync/profile_sync_service.cc

 // Copyright (c) 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/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 478 matching lines @@
 bool ProfileSyncService::ShouldDeleteSyncFolder() {
   return !IsFirstSetupComplete();
 }
 
 void ProfileSyncService::InitializeBackend(bool delete_stale_data) {
   if (!backend_) {
     NOTREACHED();
     return;
   }
 
+  if (!sync_thread_) {
+    sync_thread_ = base::MakeUnique<base::Thread>("Chrome_SyncThread");
+    base::Thread::Options options;
+    options.timer_slack = base::TIMER_SLACK_MAXIMUM;
+    CHECK(sync_thread_->StartWithOptions(options));
+  }
+
   SyncCredentials credentials = GetCredentials();
 
   if (delete_stale_data)
     ClearStaleErrors();
 
   bool enable_local_sync_backend = false;
   base::FilePath local_sync_backend_folder;
 #if defined(OS_WIN)
   enable_local_sync_backend = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableLocalSyncBackend);
@@ skipping 22 matching lines @@
       local_sync_backend_folder.Append(kLoopbackServerBackendFilename);
 #endif  // defined(OS_WIN)
 
   SyncBackendHost::HttpPostProviderFactoryGetter
       http_post_provider_factory_getter =
           base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                      base::Unretained(network_resources_.get()),
                      url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
-      this, std::move(sync_thread_), db_thread_, file_thread_,
-      GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(),
-      credentials, delete_stale_data, enable_local_sync_backend,
-      local_sync_backend_folder, std::unique_ptr<syncer::SyncManagerFactory>(
-                                     new syncer::SyncManagerFactory()),
+      this, sync_thread_.get(), db_thread_, file_thread_, GetJsEventHandler(),
+      sync_service_url_, local_device_->GetSyncUserAgent(), credentials,
+      delete_stale_data, enable_local_sync_backend, local_sync_backend_folder,
+      base::MakeUnique<syncer::SyncManagerFactory>(),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(syncer::ReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
   const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes();
@@ skipping 223 matching lines @@
 
   // Shutdown the migrator before the backend to ensure it doesn't pull a null
   // snapshot.
   migrator_.reset();
   sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>());
 
   // Move aside the backend so nobody else tries to use it while we are
   // shutting it down.
   std::unique_ptr<SyncBackendHost> doomed_backend(backend_.release());
   if (doomed_backend) {
-    sync_thread_ = doomed_backend->Shutdown(reason);
+    doomed_backend->Shutdown(reason);
     doomed_backend.reset();
   }
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   sync_enabled_weak_factory_.InvalidateWeakPtrs();
 
   startup_controller_->Reset(GetRegisteredDataTypes());
 
   // If the sync DB is getting destroyed, the local DeviceInfo is no longer
@@ skipping 1641 matching lines @@
     backend_->FlushDirectory();
 }
 
 base::FilePath ProfileSyncService::GetDirectoryPathForTest() const {
   return directory_path_;
 }
 
 base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const {
   if (sync_thread_) {
     return sync_thread_->message_loop();
-  } else if (backend_) {
-    return backend_->GetSyncLoopForTesting();
   } else {
     return nullptr;
   }
 }
 
 void ProfileSyncService::RefreshTypesForTest(syncer::ModelTypeSet types) {
   if (backend_initialized_)
     backend_->RefreshTypesForTest(types);
 }
 
@@ skipping 62 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync