Rename CalledOnValidSequencedThread() to CalledOnValidSequence().

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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 61 matching lines @@
 }
 
 SyncTaskManager::~SyncTaskManager() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   client_.reset();
   token_.reset();
 }
 
 void SyncTaskManager::Initialize(SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(!token_);
   NotifyTaskDone(
       SyncTaskToken::CreateForForegroundTask(
           weak_ptr_factory_.GetWeakPtr(), task_runner_.get()),
       status);
 }
 
 void SyncTaskManager::ScheduleTask(
     const tracked_objects::Location& from_here,
     const Task& task,
     Priority priority,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   ScheduleSyncTask(from_here,
                    std::unique_ptr<SyncTask>(new SyncTaskAdapter(task)),
                    priority, callback);
 }
 
 void SyncTaskManager::ScheduleSyncTask(
     const tracked_objects::Location& from_here,
     std::unique_ptr<SyncTask> task,
     Priority priority,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   std::unique_ptr<SyncTaskToken> token(GetToken(from_here, callback));
   if (!token) {
     PushPendingTask(
         base::Bind(&SyncTaskManager::ScheduleSyncTask,
                    weak_ptr_factory_.GetWeakPtr(), from_here,
                    base::Passed(&task), priority, callback),
         priority);
     return;
   }
   RunTask(std::move(token), std::move(task));
 }
 
 bool SyncTaskManager::ScheduleTaskIfIdle(
         const tracked_objects::Location& from_here,
         const Task& task,
         const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   return ScheduleSyncTaskIfIdle(
       from_here, std::unique_ptr<SyncTask>(new SyncTaskAdapter(task)),
       callback);
 }
 
 bool SyncTaskManager::ScheduleSyncTaskIfIdle(
     const tracked_objects::Location& from_here,
     std::unique_ptr<SyncTask> task,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   std::unique_ptr<SyncTaskToken> token(GetToken(from_here, callback));
   if (!token)
     return false;
   RunTask(std::move(token), std::move(task));
   return true;
 }
 
 // static
 void SyncTaskManager::NotifyTaskDone(std::unique_ptr<SyncTaskToken> token,
@@ skipping 38 matching lines @@
     foreground_task_token = std::move(current_task_token);
   else
     background_task_token = std::move(current_task_token);
 
   manager->UpdateTaskBlockerBody(
       std::move(foreground_task_token), std::move(background_task_token),
       std::move(task_log), std::move(task_blocker), continuation);
 }
 
 bool SyncTaskManager::IsRunningTask(int64_t token_id) const {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // 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();
 }
 
 bool SyncTaskManager::ShouldTrackTaskToken() const {
   return !worker_pool_ || !worker_pool_->IsShutdownInProgress();
 }
 
 void SyncTaskManager::NotifyTaskDoneBody(std::unique_ptr<SyncTaskToken> token,
                                          SyncStatusCode status) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(token);
 
   DVLOG(3) << "NotifyTaskDone: " << "finished with status=" << status
            << " (" << SyncStatusCodeToString(status) << ")"
            << " " << token->location().ToString();
 
   if (token->task_blocker()) {
     dependency_manager_.Erase(token->task_blocker());
     token->clear_task_blocker();
   }
@@ skipping 35 matching lines @@
       base::Bind(&SyncTaskManager::MaybeStartNextForegroundTask,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void SyncTaskManager::UpdateTaskBlockerBody(
     std::unique_ptr<SyncTaskToken> foreground_task_token,
     std::unique_ptr<SyncTaskToken> background_task_token,
     std::unique_ptr<TaskLogger::TaskLog> task_log,
     std::unique_ptr<TaskBlocker> task_blocker,
     const Continuation& continuation) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // 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(std::move(task_log));
     continuation.Run(std::move(foreground_task_token));
     return;
   }
 
@@ skipping 65 matching lines @@
 
   token_ = std::move(foreground_task_token);
   MaybeStartNextForegroundTask(nullptr);
   background_task_token->SetTaskLog(std::move(task_log));
   continuation.Run(std::move(background_task_token));
 }
 
 std::unique_ptr<SyncTaskToken> SyncTaskManager::GetToken(
     const tracked_objects::Location& from_here,
     const SyncStatusCallback& callback) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (!token_)
     return nullptr;
   token_->UpdateTask(from_here, callback);
   return std::move(token_);
 }
 
 void SyncTaskManager::PushPendingTask(
     const base::Closure& closure, Priority priority) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   pending_tasks_.push(PendingTask(closure, priority, pending_task_seq_++));
 }
 
 void SyncTaskManager::RunTask(std::unique_ptr<SyncTaskToken> token,
                               std::unique_ptr<SyncTask> task) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(!running_foreground_task_);
 
   running_foreground_task_ = std::move(task);
   running_foreground_task_->RunPreflight(std::move(token));
 }
 
 void SyncTaskManager::MaybeStartNextForegroundTask(
     std::unique_ptr<SyncTaskToken> token) {
-  DCHECK(sequence_checker_.CalledOnValidSequencedThread());
+  DCHECK(sequence_checker_.CalledOnValidSequence());
 
   if (token) {
     DCHECK(!token_);
     token_ = std::move(token);
   }
 
   if (!pending_backgrounding_task_.is_null()) {
     base::Closure closure = pending_backgrounding_task_;
     pending_backgrounding_task_.Reset();
     closure.Run();
     return;
   }
 
   if (!token_)
     return;
 
   if (!pending_tasks_.empty()) {
     base::Closure closure = pending_tasks_.top().task;
     pending_tasks_.pop();
     closure.Run();
     return;
   }
 
   if (client_)
     client_->MaybeScheduleNextTask();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system