[SyncFS] Rename BlockingFactor to TaskBlocker

chrome/browser/sync_file_system/drive_backend/sync_task_manager.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_task_manager.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 133 matching lines @@
     token->clear_callback();
     callback.Run(status);
     return;
   }
 
   if (manager)
     manager->NotifyTaskDoneBody(token.Pass(), status);
 }
 
 // static
-void SyncTaskManager::UpdateBlockingFactor(
+void SyncTaskManager::UpdateTaskBlocker(
     scoped_ptr<SyncTaskToken> current_task_token,
-    scoped_ptr<BlockingFactor> blocking_factor,
+    scoped_ptr<TaskBlocker> task_blocker,
     const Continuation& continuation) {
   DCHECK(current_task_token);
 
   SyncTaskManager* manager = current_task_token->manager();
   if (current_task_token->token_id() == SyncTaskToken::kTestingTaskTokenID) {
     DCHECK(!manager);
     continuation.Run(current_task_token.Pass());
     return;
   }
 
   if (!manager)
     return;
 
   scoped_ptr<SyncTaskToken> foreground_task_token;
   scoped_ptr<SyncTaskToken> background_task_token;
   scoped_ptr<TaskLogger::TaskLog> task_log = current_task_token->PassTaskLog();
   if (current_task_token->token_id() == SyncTaskToken::kForegroundTaskTokenID)
     foreground_task_token = current_task_token.Pass();
   else
     background_task_token = current_task_token.Pass();
 
-  manager->UpdateBlockingFactorBody(foreground_task_token.Pass(),
-                                    background_task_token.Pass(),
-                                    task_log.Pass(),
-                                    blocking_factor.Pass(),
-                                    continuation);
+  manager->UpdateTaskBlockerBody(foreground_task_token.Pass(),
+                                 background_task_token.Pass(),
+                                 task_log.Pass(),
+                                 task_blocker.Pass(),
+                                 continuation);
 }
 
 bool SyncTaskManager::IsRunningTask(int64 token_id) const {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   // If the client is gone, all task should be aborted.
   if (!client_)
     return false;
 
   if (token_id == SyncTaskToken::kForegroundTaskTokenID)
     return true;
 
   return ContainsKey(running_background_tasks_, token_id);
 }
 
 void SyncTaskManager::DetachFromSequence() {
   sequence_checker_.DetachFromSequence();
 }
 
 void SyncTaskManager::NotifyTaskDoneBody(scoped_ptr<SyncTaskToken> token,
                                          SyncStatusCode status) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(token);
 
   DVLOG(3) << "NotifyTaskDone: " << "finished with status=" << status
            << " (" << SyncStatusCodeToString(status) << ")"
            << " " << token->location().ToString();
 
-  if (token->blocking_factor()) {
-    dependency_manager_.Erase(token->blocking_factor());
-    token->clear_blocking_factor();
+  if (token->task_blocker()) {
+    dependency_manager_.Erase(token->task_blocker());
+    token->clear_task_blocker();
   }
 
   if (client_) {
     if (token->has_task_log()) {
       token->FinalizeTaskLog(SyncStatusCodeToString(status));
       client_->RecordTaskLog(token->PassTaskLog());
     }
   }
 
   scoped_ptr<SyncTask> task;
@@ skipping 20 matching lines @@
     callback.Run(status);
 
   // Post MaybeStartNextForegroundTask rather than calling it directly to avoid
   // making the call-chaing longer.
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncTaskManager::MaybeStartNextForegroundTask,
                  AsWeakPtr(), base::Passed(&token)));
 }
 
-void SyncTaskManager::UpdateBlockingFactorBody(
+void SyncTaskManager::UpdateTaskBlockerBody(
     scoped_ptr<SyncTaskToken> foreground_task_token,
     scoped_ptr<SyncTaskToken> background_task_token,
     scoped_ptr<TaskLogger::TaskLog> task_log,
-    scoped_ptr<BlockingFactor> blocking_factor,
+    scoped_ptr<TaskBlocker> task_blocker,
     const Continuation& continuation) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   // Run the task directly if the parallelization is disabled.
   if (!maximum_background_task_) {
     DCHECK(foreground_task_token);
     DCHECK(!background_task_token);
     foreground_task_token->SetTaskLog(task_log.Pass());
     continuation.Run(foreground_task_token.Pass());
     return;
   }
 
-  // Clear existing |blocking_factor| from |dependency_manager_| before
+  // Clear existing |task_blocker| from |dependency_manager_| before
   // getting |foreground_task_token|, so that we can avoid dead lock.
-  if (background_task_token && background_task_token->blocking_factor()) {
-    dependency_manager_.Erase(background_task_token->blocking_factor());
-    background_task_token->clear_blocking_factor();
+  if (background_task_token && background_task_token->task_blocker()) {
+    dependency_manager_.Erase(background_task_token->task_blocker());
+    background_task_token->clear_task_blocker();
   }
 
   // Try to get |foreground_task_token|.  If it's not available, wait for
   // current foreground task to finish.
   if (!foreground_task_token) {
     DCHECK(background_task_token);
     foreground_task_token = GetToken(background_task_token->location(),
                                      SyncStatusCallback());
     if (!foreground_task_token) {
       PushPendingTask(
-          base::Bind(&SyncTaskManager::UpdateBlockingFactorBody,
+          base::Bind(&SyncTaskManager::UpdateTaskBlockerBody,
                      AsWeakPtr(),
                      base::Passed(&foreground_task_token),
                      base::Passed(&background_task_token),
                      base::Passed(&task_log),
-                     base::Passed(&blocking_factor),
+                     base::Passed(&task_blocker),
                      continuation),
           PRIORITY_HIGH);
       MaybeStartNextForegroundTask(scoped_ptr<SyncTaskToken>());
       return;
     }
   }
 
   // Check if the task can run as a background task now.
   // If there are too many task running or any other task blocks current
   // task, wait for any other task to finish.
   bool task_number_limit_exceeded =
       !background_task_token &&
       running_background_tasks_.size() >= maximum_background_task_;
   if (task_number_limit_exceeded ||
-      !dependency_manager_.Insert(blocking_factor.get())) {
+      !dependency_manager_.Insert(task_blocker.get())) {
     DCHECK(!running_background_tasks_.empty());
     DCHECK(pending_backgrounding_task_.is_null());
 
-    // Wait for NotifyTaskDone to release a |blocking_factor|.
+    // Wait for NotifyTaskDone to release a |task_blocker|.
     pending_backgrounding_task_ =
-        base::Bind(&SyncTaskManager::UpdateBlockingFactorBody,
+        base::Bind(&SyncTaskManager::UpdateTaskBlockerBody,
                    AsWeakPtr(),
                    base::Passed(&foreground_task_token),
                    base::Passed(&background_task_token),
                    base::Passed(&task_log),
-                   base::Passed(&blocking_factor),
+                   base::Passed(&task_blocker),
                    continuation);
     return;
   }
 
   if (background_task_token) {
-    background_task_token->set_blocking_factor(blocking_factor.Pass());
+    background_task_token->set_task_blocker(task_blocker.Pass());
   } else {
     tracked_objects::Location from_here = foreground_task_token->location();
     SyncStatusCallback callback = foreground_task_token->callback();
     foreground_task_token->clear_callback();
 
     background_task_token =
         SyncTaskToken::CreateForBackgroundTask(AsWeakPtr(),
                                                task_runner_.get(),
                                                task_token_seq_++,
-                                               blocking_factor.Pass());
+                                               task_blocker.Pass());
     background_task_token->UpdateTask(from_here, callback);
     running_background_tasks_.set(background_task_token->token_id(),
                                   running_foreground_task_.Pass());
   }
 
   token_ = foreground_task_token.Pass();
   MaybeStartNextForegroundTask(scoped_ptr<SyncTaskToken>());
   background_task_token->SetTaskLog(task_log.Pass());
   continuation.Run(background_task_token.Pass());
 }
@@ skipping 50 matching lines @@
     closure.Run();
     return;
   }
 
   if (client_)
     client_->MaybeScheduleNextTask();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system