[SyncFS] Move FROM_HEREs in SyncTaskManager to its client

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

 // Copyright 2013 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_engine.h"
 
 #include "base/bind.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/drive/drive_api_service.h"
@@ skipping 147 matching lines @@
   if (!metadata_database_ && drive_service_->HasRefreshToken())
     PostInitializeTask();
 
   scoped_ptr<RegisterAppTask> task(new RegisterAppTask(this, origin.host()));
   if (task->CanFinishImmediately()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   task_manager_->ScheduleSyncTaskAtPriority(
-      task.PassAs<SyncTask>(), SyncTaskManager::PRIORITY_HIGH, callback);
+      FROM_HERE,
+      task.PassAs<SyncTask>(),
+      SyncTaskManager::PRIORITY_HIGH,
+      callback);
 }
 
 void SyncEngine::EnableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&SyncEngine::DoEnableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&SyncEngine::DoDisableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::UninstallOrigin(
     const GURL& origin,
     UninstallFlag flag,
     const SyncStatusCallback& callback) {
   task_manager_->ScheduleSyncTaskAtPriority(
+      FROM_HERE,
       scoped_ptr<SyncTask>(new UninstallAppTask(this, origin.host(), flag)),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
 }
 
 void SyncEngine::ProcessRemoteChange(
     const SyncFileCallback& callback) {
   RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(this);
   task_manager_->ScheduleSyncTask(
+      FROM_HERE,
       scoped_ptr<SyncTask>(syncer),
       base::Bind(&SyncEngine::DidProcessRemoteChange,
                  weak_ptr_factory_.GetWeakPtr(),
                  syncer, callback));
 }
 
 void SyncEngine::SetRemoteChangeProcessor(
     RemoteChangeProcessor* processor) {
   remote_change_processor_ = processor;
 }
@@ skipping 111 matching lines @@
 
 void SyncEngine::ApplyLocalChange(
     const FileChange& local_change,
     const base::FilePath& local_path,
     const SyncFileMetadata& local_metadata,
     const fileapi::FileSystemURL& url,
     const SyncStatusCallback& callback) {
   LocalToRemoteSyncer* syncer = new LocalToRemoteSyncer(
       this, local_metadata, local_change, local_path, url);
   task_manager_->ScheduleSyncTask(
+      FROM_HERE,
       scoped_ptr<SyncTask>(syncer),
       base::Bind(&SyncEngine::DidApplyLocalChange,
                  weak_ptr_factory_.GetWeakPtr(),
                  syncer, callback));
 }
 
 void SyncEngine::MaybeScheduleNextTask() {
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
@@ skipping 135 matching lines @@
 
   // This initializer task may not run if metadata_database_ is already
   // initialized when it runs.
   SyncEngineInitializer* initializer =
       new SyncEngineInitializer(this,
                                 task_runner_.get(),
                                 drive_service_.get(),
                                 base_dir_.Append(kDatabaseName),
                                 env_override_);
   task_manager_->ScheduleSyncTaskAtPriority(
+      FROM_HERE,
       scoped_ptr<SyncTask>(initializer),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&SyncEngine::DidInitialize, weak_ptr_factory_.GetWeakPtr(),
                  initializer));
 }
 
 void SyncEngine::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     if (drive_service_->HasRefreshToken()) {
@@ skipping 66 matching lines @@
   }
 
   if (status == SYNC_STATUS_UNKNOWN_ORIGIN && syncer->url().is_valid()) {
     RegisterOrigin(syncer->url().origin(),
                    base::Bind(&EmptyStatusCallback));
   }
 
   if (syncer->needs_remote_change_listing() &&
       !listing_remote_changes_) {
     task_manager_->ScheduleSyncTaskAtPriority(
+        FROM_HERE,
         scoped_ptr<SyncTask>(new ListChangesTask(this)),
         SyncTaskManager::PRIORITY_HIGH,
         base::Bind(&SyncEngine::DidFetchChanges,
                    weak_ptr_factory_.GetWeakPtr()));
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         base::TimeTicks::Now() +
         base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
@@ skipping 18 matching lines @@
     return;
 
   if (listing_remote_changes_)
     return;
 
   base::TimeTicks now = base::TimeTicks::Now();
   if (!should_check_remote_change_ && now < time_to_check_changes_) {
     if (!metadata_database_->HasDirtyTracker() && should_check_conflict_) {
       should_check_conflict_ = false;
       task_manager_->ScheduleSyncTaskIfIdle(
+          FROM_HERE,
           scoped_ptr<SyncTask>(new ConflictResolver(this)),
           base::Bind(&SyncEngine::DidResolveConflict,
                      weak_ptr_factory_.GetWeakPtr()));
     }
     return;
   }
 
   if (task_manager_->ScheduleSyncTaskIfIdle(
+          FROM_HERE,
           scoped_ptr<SyncTask>(new ListChangesTask(this)),
           base::Bind(&SyncEngine::DidFetchChanges,
                      weak_ptr_factory_.GetWeakPtr()))) {
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         now + base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
 }
 
@@ skipping 106 matching lines @@
         tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
     if (is_app_enabled && !is_app_root_tracker_enabled)
       EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
     else if (!is_app_enabled && is_app_root_tracker_enabled)
       DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system