[SyncFS] Construct and destruct sync_worker in worker_task_runner

chrome/browser/sync_file_system/drive_backend/sync_worker.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 "chrome/browser/sync_file_system/drive_backend/sync_worker.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 67 matching lines @@
       (*status)[app_id] = SyncWorker::APP_STATUS_DISABLED;
     else
       (*status)[app_id] = SyncWorker::APP_STATUS_ENABLED;
   }
 
   callback.Run();
 }
 
 }  // namespace
 
-scoped_ptr<SyncWorker> SyncWorker::CreateOnWorker(
+SyncWorker::SyncWorker(
     const base::FilePath& base_dir,
-    Observer* observer,
     const base::WeakPtr<ExtensionServiceInterface>& extension_service,
     scoped_ptr<SyncEngineContext> sync_engine_context,
-    leveldb::Env* env_override) {
-  scoped_ptr<SyncWorker> sync_worker(
-      new SyncWorker(base_dir,
-                     extension_service,
-                     sync_engine_context.Pass(),
-                     env_override));
-  sync_worker->AddObserver(observer);
-  sync_worker->Initialize();
-
-  return sync_worker.Pass();
-}
+    leveldb::Env* env_override)
+    : base_dir_(base_dir),
+      env_override_(env_override),
+      service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
+      should_check_conflict_(true),
+      should_check_remote_change_(true),
+      listing_remote_changes_(false),
+      sync_enabled_(false),
+      default_conflict_resolution_policy_(
+          CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN),
+      network_available_(false),
+      extension_service_(extension_service),
+      context_(sync_engine_context.Pass()),
+      weak_ptr_factory_(this) {}
 
 SyncWorker::~SyncWorker() {}
 
 void SyncWorker::Initialize() {
   DCHECK(!task_manager_);
 
   task_manager_.reset(new SyncTaskManager(
       weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
@@ skipping 12 matching lines @@
     PostInitializeTask();
 
   scoped_ptr<RegisterAppTask> task(
       new RegisterAppTask(context_.get(), origin.host()));
   if (task->CanFinishImmediately()) {
     context_->GetUITaskRunner()->PostTask(
         FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
     return;
   }
 
-  // TODO(peria): Forward |callback| to UI thread.
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       task.PassAs<SyncTask>(),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncWorker::EnableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  // TODO(peria): Forward |callback| to UI thread.
   task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncWorker::DoEnableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncWorker::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
-  // TODO(peria): Forward |callback| to UI thread.
   task_manager_->ScheduleTask(
       FROM_HERE,
       base::Bind(&SyncWorker::DoDisableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncWorker::UninstallOrigin(
     const GURL& origin,
     RemoteFileSyncService::UninstallFlag flag,
     const SyncStatusCallback& callback) {
-  // TODO(peria): Forward |callback| to UI thread.
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(
           new UninstallAppTask(context_.get(), origin.host(), flag)),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncWorker::ProcessRemoteChange(
     const SyncFileCallback& callback) {
   RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(context_.get());
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(syncer),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorker::DidProcessRemoteChange,
                  weak_ptr_factory_.GetWeakPtr(),
-                 syncer, callback));
+                 syncer,
+                 callback));
 }
 
 void SyncWorker::SetRemoteChangeProcessor(
     RemoteChangeProcessorOnWorker* remote_change_processor_on_worker) {
   context_->SetRemoteChangeProcessor(remote_change_processor_on_worker);
 }
 
 RemoteServiceState SyncWorker::GetCurrentState() const {
   if (!sync_enabled_)
     return REMOTE_SERVICE_DISABLED;
@@ skipping 81 matching lines @@
     const fileapi::FileSystemURL& url,
     const SyncStatusCallback& callback) {
   LocalToRemoteSyncer* syncer = new LocalToRemoteSyncer(
       context_.get(), local_metadata, local_change, local_path, url);
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(syncer),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorker::DidApplyLocalChange,
                  weak_ptr_factory_.GetWeakPtr(),
-                 syncer, callback));
+                 syncer,
+                 callback));
 }
 
 void SyncWorker::MaybeScheduleNextTask() {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   // TODO(tzik): Notify observer of OnRemoteChangeQueueUpdated.
   // TODO(tzik): Add an interface to get the number of dirty trackers to
   // MetadataDatabase.
 
@@ skipping 69 matching lines @@
 }
 
 SyncTaskManager* SyncWorker::GetSyncTaskManager() {
   return task_manager_.get();
 }
 
 void SyncWorker::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
-SyncWorker::SyncWorker(
-    const base::FilePath& base_dir,
-    const base::WeakPtr<ExtensionServiceInterface>& extension_service,
-    scoped_ptr<SyncEngineContext> sync_engine_context,
-    leveldb::Env* env_override)
-    : base_dir_(base_dir),
-      env_override_(env_override),
-      service_state_(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE),
-      should_check_conflict_(true),
-      should_check_remote_change_(true),
-      listing_remote_changes_(false),
-      sync_enabled_(false),
-      default_conflict_resolution_policy_(
-          CONFLICT_RESOLUTION_POLICY_LAST_WRITE_WIN),
-      network_available_(false),
-      extension_service_(extension_service),
-      context_(sync_engine_context.Pass()),
-      weak_ptr_factory_(this) {}
-
 void SyncWorker::DoDisableApp(const std::string& app_id,
                               const SyncStatusCallback& callback) {
   if (GetMetadataDatabase()) {
     GetMetadataDatabase()->DisableApp(app_id, callback);
   } else {
     context_->GetUITaskRunner()->PostTask(
         FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
   }
 }
 
@@ skipping 292 matching lines @@
             "Service state changed: %d->%d: %s",
             old_state, GetCurrentState(), description.c_str());
 
   FOR_EACH_OBSERVER(
       Observer, observers_,
       UpdateServiceState(GetCurrentState(), description));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system