[Sync] Move sync thread ownership to ProfileSyncService.

components/sync/driver/glue/sync_backend_registrar.h

 // 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.
 
 #ifndef COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_REGISTRAR_H_
 #define COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_REGISTRAR_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 17 matching lines @@
 
 // A class that keep track of the workers, change processors, and
 // routing info for the enabled sync types, and also routes change
 // events to the right processors.
 class SyncBackendRegistrar : public SyncManager::ChangeDelegate {
  public:
   // |name| is used for debugging. Must be created on the UI thread.
   SyncBackendRegistrar(
       const std::string& name,
       SyncClient* sync_client,
-      std::unique_ptr<base::Thread> sync_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& db_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_thread);
 
   // A SyncBackendRegistrar is owned by a SyncBackendHostImpl. It is destroyed
   // by SyncBackendHostImpl::Shutdown() which performs the following operations
   // on the UI thread:
   //
   //   1) Call SyncBackendRegistrar::RequestWorkerStopOnUIThread().
   //   2) Post a SyncBackendHostCore::DoShutdown() task to the sync thread. This
@@ skipping 61 matching lines @@
   // any thread.
   void OnChangesApplied(ModelType model_type,
                         int64_t model_version,
                         const BaseTransaction* trans,
                         const ImmutableChangeRecordList& changes) override;
   void OnChangesComplete(ModelType model_type) override;
 
   void GetWorkers(std::vector<scoped_refptr<ModelSafeWorker>>* out);
   void GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out);
 
-  // Release ownership of |sync_thread_|. Called when sync is disabled.
-  std::unique_ptr<base::Thread> ReleaseSyncThread();
-
-  base::Thread* sync_thread();
-
  private:
   typedef std::map<ModelSafeGroup, scoped_refptr<ModelSafeWorker>> WorkerMap;
   typedef std::map<ModelType, ChangeProcessor*> ProcessorMap;
 
   // Add a worker for |group| to the worker map if one can be created.
   void MaybeAddWorker(ModelSafeGroup group);
 
   // Returns the change processor for the given model, or null if none
   // exists.  Must be called from |group|'s native thread.
   ChangeProcessor* GetProcessor(ModelType type) const;
@@ skipping 35 matching lines @@
 
   // The types that were enabled as of the last configuration. Updated on each
   // call to ConfigureDataTypes as well as SetInitialTypes.
   ModelTypeSet last_configured_types_;
 
   // References to the thread task runners that sync depends on.
   const scoped_refptr<base::SingleThreadTaskRunner> ui_thread_;
   const scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
   const scoped_refptr<base::SingleThreadTaskRunner> file_thread_;
 
-  std::unique_ptr<base::Thread> sync_thread_;
-
   // Set of types with non-blocking implementation (as opposed to directory
   // based).
   ModelTypeSet non_blocking_types_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendRegistrar);
 };
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_DRIVER_GLUE_SYNC_BACKEND_REGISTRAR_H_