[SyncFS] Move FROM_HEREs in SyncTaskManager to its client

Move location marker to make logs meaningful.

BUG=344769

Review URL: https://codereview.chromium.org/190243003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@255882 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/sync_file_system/drive_backend/sync_engine.cc

@@ -165,13 +165,17 @@ void SyncEngine::RegisterOrigin(
   }
 
   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()),
@@ -183,6 +187,7 @@ void SyncEngine::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&SyncEngine::DoDisableApp,
                  weak_ptr_factory_.GetWeakPtr(),
                  origin.host()),
@@ -195,6 +200,7 @@ void SyncEngine::UninstallOrigin(
     UninstallFlag flag,
     const SyncStatusCallback& callback) {
   task_manager_->ScheduleSyncTaskAtPriority(
+      FROM_HERE,
       scoped_ptr<SyncTask>(new UninstallAppTask(this, origin.host(), flag)),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
@@ -204,6 +210,7 @@ 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(),
@@ -335,6 +342,7 @@ void SyncEngine::ApplyLocalChange(
   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(),
@@ -490,6 +498,7 @@ void SyncEngine::PostInitializeTask() {
                                 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(),
@@ -576,6 +585,7 @@ void SyncEngine::DidApplyLocalChange(LocalToRemoteSyncer* syncer,
   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,
@@ -614,6 +624,7 @@ void SyncEngine::MaybeStartFetchChanges() {
     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()));
@@ -622,6 +633,7 @@ void SyncEngine::MaybeStartFetchChanges() {
   }
 
   if (task_manager_->ScheduleSyncTaskIfIdle(
+          FROM_HERE,
           scoped_ptr<SyncTask>(new ListChangesTask(this)),
           base::Bind(&SyncEngine::DidFetchChanges,
                      weak_ptr_factory_.GetWeakPtr()))) {

chrome/browser/sync_file_system/drive_backend/sync_engine_unittest.cc

@@ -278,6 +278,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
   EXPECT_EQ(REMOTE_SERVICE_OK, sync_engine()->GetCurrentState());
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_STATUS_AUTHENTICATION_FAILED),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -285,6 +286,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_AUTHENTICATION_REQUIRED));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_STATUS_ACCESS_FORBIDDEN),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -292,6 +294,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_AUTHENTICATION_REQUIRED));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_STATUS_SERVICE_TEMPORARILY_UNAVAILABLE),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -299,6 +302,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_STATUS_NETWORK_ERROR),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -306,6 +310,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_STATUS_ABORT),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -313,6 +318,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_STATUS_FAILED),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -320,6 +326,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_TEMPORARY_UNAVAILABLE));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_CORRUPTION),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -327,6 +334,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_DISABLED));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_IO_ERROR),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -334,6 +342,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_DISABLED));
 
   GetSyncEngineTaskManager()->ScheduleTask(
+      FROM_HERE,
       base::Bind(&EmptyTask, SYNC_DATABASE_ERROR_FAILED),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -341,6 +350,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_DISABLED));
 
   GetSyncEngineTaskManager()->ScheduleSyncTask(
+      FROM_HERE,
       scoped_ptr<SyncTask>(new MockSyncTask(false)),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),
@@ -348,6 +358,7 @@ TEST_F(SyncEngineTest, UpdateServiceState) {
                  REMOTE_SERVICE_DISABLED));
 
   GetSyncEngineTaskManager()->ScheduleSyncTask(
+      FROM_HERE,
       scoped_ptr<SyncTask>(new MockSyncTask(true)),
       base::Bind(&SyncEngineTest::CheckServiceState,
                  AsWeakPtr(),

chrome/browser/sync_file_system/drive_backend_v1/drive_file_sync_service.cc

@@ -151,6 +151,7 @@ void DriveFileSyncService::RegisterOrigin(
   pending_origin_operations_.Push(origin, OriginOperation::REGISTERING);
 
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoRegisterOrigin, AsWeakPtr(), origin),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
@@ -161,6 +162,7 @@ void DriveFileSyncService::EnableOrigin(
     const SyncStatusCallback& callback) {
   pending_origin_operations_.Push(origin, OriginOperation::ENABLING);
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoEnableOrigin, AsWeakPtr(), origin),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
@@ -171,6 +173,7 @@ void DriveFileSyncService::DisableOrigin(
     const SyncStatusCallback& callback) {
   pending_origin_operations_.Push(origin, OriginOperation::DISABLING);
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoDisableOrigin, AsWeakPtr(), origin),
       SyncTaskManager::PRIORITY_HIGH,
       callback);
@@ -182,6 +185,7 @@ void DriveFileSyncService::UninstallOrigin(
     const SyncStatusCallback& callback) {
   pending_origin_operations_.Push(origin, OriginOperation::UNINSTALLING);
   task_manager_->ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoUninstallOrigin, AsWeakPtr(),
                  origin, flag),
       SyncTaskManager::PRIORITY_HIGH,
@@ -191,6 +195,7 @@ void DriveFileSyncService::UninstallOrigin(
 void DriveFileSyncService::ProcessRemoteChange(
     const SyncFileCallback& callback) {
   task_manager_->ScheduleTask(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoProcessRemoteChange, AsWeakPtr(),
                  callback),
       base::Bind(&EmptyStatusCallback));
@@ -295,6 +300,7 @@ void DriveFileSyncService::GetRemoteVersions(
     const fileapi::FileSystemURL& url,
     const RemoteVersionsCallback& callback) {
   task_manager_->ScheduleTask(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoGetRemoteVersions, AsWeakPtr(),
                  url, callback),
       base::Bind(&EmptyStatusCallback));
@@ -305,6 +311,7 @@ void DriveFileSyncService::DownloadRemoteVersion(
     const std::string& version_id,
     const DownloadVersionCallback& callback) {
   task_manager_->ScheduleTask(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoDownloadRemoteVersion, AsWeakPtr(),
                  url, version_id, callback),
       base::Bind(&EmptyStatusCallback));
@@ -320,6 +327,7 @@ void DriveFileSyncService::ApplyLocalChange(
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   task_manager_->ScheduleTask(
+      FROM_HERE,
       base::Bind(&DriveFileSyncService::DoApplyLocalChange, AsWeakPtr(),
                  local_file_change,
                  local_file_path,
@@ -1178,6 +1186,7 @@ void DriveFileSyncService::MaybeStartFetchChanges() {
   if (!pending_batch_sync_origins_.empty()) {
     if (GetCurrentState() == REMOTE_SERVICE_OK || may_have_unfetched_changes_) {
       task_manager_->ScheduleTaskIfIdle(
+          FROM_HERE,
           base::Bind(&DriveFileSyncService::StartBatchSync, AsWeakPtr()),
           SyncStatusCallback());
     }
@@ -1187,6 +1196,7 @@ void DriveFileSyncService::MaybeStartFetchChanges() {
   if (may_have_unfetched_changes_ &&
       !metadata_store_->incremental_sync_origins().empty()) {
     task_manager_->ScheduleTaskIfIdle(
+        FROM_HERE,
         base::Bind(&DriveFileSyncService::FetchChangesForIncrementalSync,
                    AsWeakPtr()),
         SyncStatusCallback());

chrome/browser/sync_file_system/sync_task_manager.cc

@@ -84,25 +84,28 @@ void SyncTaskManager::Initialize(SyncStatusCode status) {
 }
 
 void SyncTaskManager::ScheduleTask(
+    const tracked_objects::Location& from_here,
     const Task& task,
     const SyncStatusCallback& callback) {
-  ScheduleTaskAtPriority(task, PRIORITY_MED, callback);
+  ScheduleTaskAtPriority(from_here, task, PRIORITY_MED, callback);
 }
 
 void SyncTaskManager::ScheduleSyncTask(
+    const tracked_objects::Location& from_here,
     scoped_ptr<SyncTask> task,
     const SyncStatusCallback& callback) {
-  ScheduleSyncTaskAtPriority(task.Pass(), PRIORITY_MED, callback);
+  ScheduleSyncTaskAtPriority(from_here, task.Pass(), PRIORITY_MED, callback);
 }
 
 void SyncTaskManager::ScheduleTaskAtPriority(
+    const tracked_objects::Location& from_here,
     const Task& task,
     Priority priority,
     const SyncStatusCallback& callback) {
-  scoped_ptr<TaskToken> token(GetToken(FROM_HERE));
+  scoped_ptr<TaskToken> token(GetToken(from_here));
   if (!token) {
     PushPendingTask(
-        base::Bind(&SyncTaskManager::ScheduleTask, AsWeakPtr(),
+        base::Bind(&SyncTaskManager::ScheduleTask, AsWeakPtr(), from_here,
                    task, callback),
         priority);
     return;
@@ -111,14 +114,15 @@ void SyncTaskManager::ScheduleTaskAtPriority(
 }
 
 void SyncTaskManager::ScheduleSyncTaskAtPriority(
+    const tracked_objects::Location& from_here,
     scoped_ptr<SyncTask> task,
     Priority priority,
     const SyncStatusCallback& callback) {
-  scoped_ptr<TaskToken> token(GetToken(FROM_HERE));
+  scoped_ptr<TaskToken> token(GetToken(from_here));
   if (!token) {
     PushPendingTask(
-        base::Bind(&SyncTaskManager::ScheduleSyncTask,
-                   AsWeakPtr(), base::Passed(&task), callback),
+        base::Bind(&SyncTaskManager::ScheduleSyncTask, AsWeakPtr(), from_here,
+                   base::Passed(&task), callback),
         priority);
     return;
   }
@@ -127,9 +131,11 @@ void SyncTaskManager::ScheduleSyncTaskAtPriority(
   running_task_->Run(CreateCompletionCallback(token.Pass(), callback));
 }
 
-bool SyncTaskManager::ScheduleTaskIfIdle(const Task& task,
-                                         const SyncStatusCallback& callback) {
-  scoped_ptr<TaskToken> token(GetToken(FROM_HERE));
+bool SyncTaskManager::ScheduleTaskIfIdle(
+        const tracked_objects::Location& from_here,
+        const Task& task,
+        const SyncStatusCallback& callback) {
+  scoped_ptr<TaskToken> token(GetToken(from_here));
   if (!token)
     return false;
   task.Run(CreateCompletionCallback(token.Pass(), callback));
@@ -137,9 +143,10 @@ bool SyncTaskManager::ScheduleTaskIfIdle(const Task& task,
 }
 
 bool SyncTaskManager::ScheduleSyncTaskIfIdle(
+    const tracked_objects::Location& from_here,
     scoped_ptr<SyncTask> task,
     const SyncStatusCallback& callback) {
-  scoped_ptr<TaskToken> token(GetToken(FROM_HERE));
+  scoped_ptr<TaskToken> token(GetToken(from_here));
   if (!token)
     return false;
   DCHECK(!running_task_);

chrome/browser/sync_file_system/sync_task_manager.h

@@ -57,23 +57,30 @@ class SyncTaskManager
   void Initialize(SyncStatusCode status);
 
   // Schedules a task at PRIORITY_MED.
-  void ScheduleTask(const Task& task,
+  void ScheduleTask(const tracked_objects::Location& from_here,
+                    const Task& task,
                     const SyncStatusCallback& callback);
-  void ScheduleSyncTask(scoped_ptr<SyncTask> task,
+  void ScheduleSyncTask(const tracked_objects::Location& from_here,
+                        scoped_ptr<SyncTask> task,
                         const SyncStatusCallback& callback);
 
   // Schedules a task at the given priority.
-  void ScheduleTaskAtPriority(const Task& task,
+  void ScheduleTaskAtPriority(const tracked_objects::Location& from_here,
+                              const Task& task,
                               Priority priority,
                               const SyncStatusCallback& callback);
-  void ScheduleSyncTaskAtPriority(scoped_ptr<SyncTask> task,
+  void ScheduleSyncTaskAtPriority(const tracked_objects::Location& from_here,
+                                  scoped_ptr<SyncTask> task,
                                   Priority priority,
                                   const SyncStatusCallback& callback);
 
   // Runs the posted task only when we're idle.  Returns true if tha task is
   // scheduled.
-  bool ScheduleTaskIfIdle(const Task& task, const SyncStatusCallback& callback);
-  bool ScheduleSyncTaskIfIdle(scoped_ptr<SyncTask> task,
+  bool ScheduleTaskIfIdle(const tracked_objects::Location& from_here,
+                          const Task& task,
+                          const SyncStatusCallback& callback);
+  bool ScheduleSyncTaskIfIdle(const tracked_objects::Location& from_here,
+                              scoped_ptr<SyncTask> task,
                               const SyncStatusCallback& callback);
 
   void NotifyTaskDone(scoped_ptr<TaskToken> token,

chrome/browser/sync_file_system/sync_task_manager_unittest.cc

@@ -65,6 +65,7 @@ class TaskManagerClient
   void ScheduleTask(SyncStatusCode status_to_return,
                     const SyncStatusCallback& callback) {
     task_manager_->ScheduleTask(
+        FROM_HERE,
         base::Bind(&TaskManagerClient::DoTask, AsWeakPtr(),
                    status_to_return, false /* idle */),
         callback);
@@ -72,6 +73,7 @@ class TaskManagerClient
 
   void ScheduleTaskIfIdle(SyncStatusCode status_to_return) {
     task_manager_->ScheduleTaskIfIdle(
+        FROM_HERE,
         base::Bind(&TaskManagerClient::DoTask, AsWeakPtr(),
                    status_to_return, true /* idle */),
         SyncStatusCallback());
@@ -245,6 +247,7 @@ TEST(SyncTaskManagerTest, ScheduleAndCancelSyncTask) {
     SyncTaskManager task_manager((base::WeakPtr<SyncTaskManager::Client>()));
     task_manager.Initialize(SYNC_STATUS_OK);
     task_manager.ScheduleSyncTask(
+        FROM_HERE,
         scoped_ptr<SyncTask>(new MultihopSyncTask(
             &task_started, &task_completed)),
         base::Bind(&IncrementAndAssign, 0, &callback_count, &status));
@@ -272,6 +275,7 @@ TEST(SyncTaskManagerTest, ScheduleAndCancelTask) {
     MultihopSyncTask* task = new MultihopSyncTask(
         &task_started, &task_completed);
     task_manager.ScheduleTask(
+        FROM_HERE,
         base::Bind(&MultihopSyncTask::Run, base::Unretained(task)),
         base::Bind(&IncrementAndAssignWithOwnedPointer<MultihopSyncTask>,
                    base::Owned(task), &callback_count, &status));
@@ -299,30 +303,35 @@ TEST(SyncTaskManagerTest, ScheduleTaskAtPriority) {
   // This will run first even if its priority is low, since there're no
   // pending tasks.
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus1),
       SyncTaskManager::PRIORITY_LOW,
       base::Bind(&IncrementAndAssign, 0, &callback_count, &callback_status1));
 
   // This runs last (expected counter == 4).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus2),
       SyncTaskManager::PRIORITY_LOW,
       base::Bind(&IncrementAndAssign, 4, &callback_count, &callback_status2));
 
   // This runs second (expected counter == 1).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus3),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&IncrementAndAssign, 1, &callback_count, &callback_status3));
 
   // This runs fourth (expected counter == 3).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus4),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&IncrementAndAssign, 3, &callback_count, &callback_status4));
 
   // This runs third (expected counter == 2).
   task_manager.ScheduleTaskAtPriority(
+      FROM_HERE,
       base::Bind(&DumbTask, kStatus5),
       SyncTaskManager::PRIORITY_HIGH,
       base::Bind(&IncrementAndAssign, 2, &callback_count, &callback_status5));