[SyncFS] Make task invocation in SyncTaskRunner async

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"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/sync_file_metadata.h"
 
 using fileapi::FileSystemURL;
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
@@ skipping 26 matching lines @@
 bool SyncTaskManager::PendingTaskComparator::operator()(
     const PendingTask& left,
     const PendingTask& right) const {
   if (left.priority != right.priority)
     return left.priority < right.priority;
   return left.seq > right.seq;
 }
 
 SyncTaskManager::SyncTaskManager(
     base::WeakPtr<Client> client,
-    size_t maximum_background_task)
+    size_t maximum_background_task,
+    base::SequencedTaskRunner* task_runner)
     : client_(client),
       maximum_background_task_(maximum_background_task),
       pending_task_seq_(0),
-      task_token_seq_(SyncTaskToken::kMinimumBackgroundTaskTokenID) {
+      task_token_seq_(SyncTaskToken::kMinimumBackgroundTaskTokenID),
+      task_runner_(task_runner) {
 }
 
 SyncTaskManager::~SyncTaskManager() {
   client_.reset();
   token_.reset();
 }
 
 void SyncTaskManager::Initialize(SyncStatusCode status) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!token_);
@@ skipping 148 matching lines @@
   scoped_ptr<SyncTask> task;
   SyncStatusCallback callback = token->callback();
   token->clear_callback();
   if (token->token_id() == SyncTaskToken::kForegroundTaskTokenID) {
     token_ = token.Pass();
     task = running_foreground_task_.Pass();
   } else {
     task = running_background_tasks_.take_and_erase(token->token_id());
   }
 
+  // Acquire the token to prevent a new task to jump into the queue.
+  token = token_.Pass();
+
   bool task_used_network = false;
   if (task)
     task_used_network = task->used_network();
 
   if (client_)
     client_->NotifyLastOperationStatus(status, task_used_network);
 
   if (!callback.is_null())
     callback.Run(status);
 
-  StartNextTask();
+  // 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(
     scoped_ptr<SyncTaskToken> foreground_task_token,
     scoped_ptr<SyncTaskToken> background_task_token,
     scoped_ptr<TaskLogger::TaskLog> task_log,
     scoped_ptr<BlockingFactor> blocking_factor,
     const Continuation& continuation) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
@@ skipping 22 matching lines @@
     if (!foreground_task_token) {
       PushPendingTask(
           base::Bind(&SyncTaskManager::UpdateBlockingFactorBody,
                      AsWeakPtr(),
                      base::Passed(&foreground_task_token),
                      base::Passed(&background_task_token),
                      base::Passed(&task_log),
                      base::Passed(&blocking_factor),
                      continuation),
           PRIORITY_HIGH);
-      StartNextTask();
+      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_;
@@ skipping 25 matching lines @@
         SyncTaskToken::CreateForBackgroundTask(
             AsWeakPtr(),
             task_token_seq_++,
             blocking_factor.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();
-  StartNextTask();
+  MaybeStartNextForegroundTask(scoped_ptr<SyncTaskToken>());
   background_task_token->SetTaskLog(task_log.Pass());
   continuation.Run(background_task_token.Pass());
 }
 
 scoped_ptr<SyncTaskToken> SyncTaskManager::GetToken(
     const tracked_objects::Location& from_here,
     const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!token_)
@@ skipping 11 matching lines @@
 
 void SyncTaskManager::RunTask(scoped_ptr<SyncTaskToken> token,
                               scoped_ptr<SyncTask> task) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!running_foreground_task_);
 
   running_foreground_task_ = task.Pass();
   running_foreground_task_->RunPreflight(token.Pass());
 }
 
-void SyncTaskManager::StartNextTask() {
+void SyncTaskManager::MaybeStartNextForegroundTask(
+    scoped_ptr<SyncTaskToken> token) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
+  if (token) {
+    DCHECK(!token_);
+    token_ = token.Pass();
+  }
+
   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