[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();
 }
 
 SyncWorker::~SyncWorker() {}
 
 void SyncWorker::Initialize() {
   DCHECK(!task_manager_);
 
   task_manager_.reset(new SyncTaskManager(
-      weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */));
+      AsWeakPtr(),
+      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(),
+                 AsWeakPtr(),
                  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(),
+                 AsWeakPtr(),
                  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(),
+                 AsWeakPtr(),
                  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_)
@@ skipping 81 matching lines @@
     const SyncFileMetadata& local_metadata,
     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(),
+                 AsWeakPtr(),
                  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 86 matching lines @@
       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) {}
+      context_(sync_engine_context.Pass()) {}
 
 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 15 matching lines @@
   // already initialized when it runs.
   SyncEngineInitializer* initializer =
       new SyncEngineInitializer(context_.get(),
                                 base_dir_.Append(kDatabaseName),
                                 env_override_);
   task_manager_->ScheduleSyncTask(
       FROM_HERE,
       scoped_ptr<SyncTask>(initializer),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&SyncWorker::DidInitialize,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 AsWeakPtr(),
                  initializer));
 }
 
 void SyncWorker::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     if (GetDriveService()->HasRefreshToken()) {
       UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
                          "Could not initialize remote service");
     } else {
@@ skipping 14 matching lines @@
 void SyncWorker::UpdateRegisteredApp() {
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   DCHECK(metadata_db);
 
   scoped_ptr<std::vector<std::string> > app_ids(new std::vector<std::string>);
   metadata_db->GetRegisteredAppIDs(app_ids.get());
 
   AppStatusMap* app_status = new AppStatusMap;
   base::Closure callback =
       base::Bind(&SyncWorker::DidQueryAppStatus,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 AsWeakPtr(),
                  base::Owned(app_status));
 
   context_->GetUITaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&QueryAppStatusOnUIThread,
                  extension_service_,
                  base::Owned(app_ids.release()),
                  app_status,
                  RelayCallbackToTaskRunner(
                      context_->GetWorkerTaskRunner(),
@@ skipping 93 matching lines @@
                    base::Bind(&EmptyStatusCallback));
   }
 
   if (syncer->needs_remote_change_listing() &&
       !listing_remote_changes_) {
     task_manager_->ScheduleSyncTask(
         FROM_HERE,
         scoped_ptr<SyncTask>(new ListChangesTask(context_.get())),
         SyncTaskManager::PRIORITY_HIGH,
         base::Bind(&SyncWorker::DidFetchChanges,
-                   weak_ptr_factory_.GetWeakPtr()));
+                   AsWeakPtr()));
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         base::TimeTicks::Now() +
         base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
 
   if (status == SYNC_STATUS_OK)
     should_check_conflict_ = true;
 
@@ skipping 12 matching lines @@
 
   base::TimeTicks now = base::TimeTicks::Now();
   if (!should_check_remote_change_ && now < time_to_check_changes_) {
     if (!GetMetadataDatabase()->HasDirtyTracker() &&
         should_check_conflict_) {
       should_check_conflict_ = false;
       task_manager_->ScheduleSyncTaskIfIdle(
           FROM_HERE,
           scoped_ptr<SyncTask>(new ConflictResolver(context_.get())),
           base::Bind(&SyncWorker::DidResolveConflict,
-                     weak_ptr_factory_.GetWeakPtr()));
+                     AsWeakPtr()));
     }
     return;
   }
 
   if (task_manager_->ScheduleSyncTaskIfIdle(
           FROM_HERE,
           scoped_ptr<SyncTask>(new ListChangesTask(context_.get())),
           base::Bind(&SyncWorker::DidFetchChanges,
-                     weak_ptr_factory_.GetWeakPtr()))) {
+                     AsWeakPtr()))) {
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         now + base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
 }
 
 void SyncWorker::DidResolveConflict(SyncStatusCode status) {
   if (status == SYNC_STATUS_OK)
     should_check_conflict_ = true;
@@ skipping 66 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