[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
 
+// static
 scoped_ptr<SyncWorker> SyncWorker::CreateOnWorker(
     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();
 }
 
+// static
+void SyncWorker::DestructOnWorker(scoped_ptr<SyncWorker> sync_worker,
+                                  scoped_ptr<Observer> worker_observer) {
+  worker_observer.reset();
+  sync_worker.reset();
+}
+
 SyncWorker::~SyncWorker() {}
 
 void SyncWorker::Initialize() {
   DCHECK(!task_manager_);
 
   task_manager_.reset(new SyncTaskManager(
-      weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */));
+      weak_ptr_factory_.GetWeakPtr(),
+      0 /* maximum_background_task */));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
   PostInitializeTask();
 
   net::NetworkChangeNotifier::ConnectionType type =
       net::NetworkChangeNotifier::GetConnectionType();
   network_available_ =
       type != net::NetworkChangeNotifier::CONNECTION_NONE;
 }
 
 void SyncWorker::RegisterOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   if (!GetMetadataDatabase() && GetDriveService()->HasRefreshToken())
     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) {
@@ skipping 520 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