[SyncFS] Make SyncEngineInitializer run as a background task

BUG=344769

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

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

6 files changed, 174 insertions, 127 deletions

diff --git a/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc b/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc
index 3c484d6..8e2b25d 100644
--- a/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/conflict_resolver_unittest.cc
@@ -94,16 +94,29 @@ class ConflictResolverTest : public testing::Test {
   }
 
   void InitializeMetadataDatabase() {
-    SyncEngineInitializer initializer(context_.get(),
-                                      base::MessageLoopProxy::current(),
-                                      context_->GetDriveService(),
-                                      database_dir_.path(),
-                                      in_memory_env_.get());
+    SyncEngineInitializer* initializer =
+        new SyncEngineInitializer(context_.get(),
+                                  base::MessageLoopProxy::current(),
+                                  context_->GetDriveService(),
+                                  database_dir_.path(),
+                                  in_memory_env_.get());
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    initializer.RunSequential(CreateResultReceiver(&status));
+    sync_task_manager_->ScheduleSyncTask(
+        FROM_HERE,
+        scoped_ptr<SyncTask>(initializer),
+        SyncTaskManager::PRIORITY_MED,
+        base::Bind(&ConflictResolverTest::DidInitializeMetadataDatabase,
+                   base::Unretained(this), initializer, &status));
+
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(SYNC_STATUS_OK, status);
-    context_->SetMetadataDatabase(initializer.PassMetadataDatabase());
+  }
+
+  void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
+                                     SyncStatusCode* status_out,
+                                     SyncStatusCode status) {
+    context_->SetMetadataDatabase(initializer->PassMetadataDatabase());
+    *status_out = status;
   }
 
   void RegisterApp(const std::string& app_id,
diff --git a/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc b/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc
index 92034e4..f10debb 100644
--- a/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer_unittest.cc
@@ -94,16 +94,30 @@ class LocalToRemoteSyncerTest : public testing::Test {
   }
 
   void InitializeMetadataDatabase() {
-    SyncEngineInitializer initializer(context_.get(),
-                                      base::MessageLoopProxy::current(),
-                                      context_->GetDriveService(),
-                                      database_dir_.path(),
-                                      in_memory_env_.get());
+    SyncEngineInitializer* initializer =
+        new SyncEngineInitializer(context_.get(),
+                                  base::MessageLoopProxy::current(),
+                                  context_->GetDriveService(),
+                                  database_dir_.path(),
+                                  in_memory_env_.get());
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    initializer.RunSequential(CreateResultReceiver(&status));
+
+    sync_task_manager_->ScheduleSyncTask(
+        FROM_HERE,
+        scoped_ptr<SyncTask>(initializer),
+        SyncTaskManager::PRIORITY_MED,
+        base::Bind(&LocalToRemoteSyncerTest::DidInitializeMetadataDatabase,
+                   base::Unretained(this), initializer, &status));
+
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(SYNC_STATUS_OK, status);
-    context_->SetMetadataDatabase(initializer.PassMetadataDatabase());
+  }
+
+  void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
+                                     SyncStatusCode* status_out,
+                                     SyncStatusCode status) {
+    *status_out = status;
+    context_->SetMetadataDatabase(initializer->PassMetadataDatabase());
   }
 
   void RegisterApp(const std::string& app_id,
diff --git a/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc b/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc
index a8a9e6d..49690ae 100644
--- a/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer_unittest.cc
@@ -96,18 +96,34 @@ class RemoteToLocalSyncerTest : public testing::Test {
   }
 
   void InitializeMetadataDatabase() {
-    SyncEngineInitializer initializer(context_.get(),
-                                      base::MessageLoopProxy::current(),
-                                      context_->GetDriveService(),
-                                      database_dir_.path(),
-                                      in_memory_env_.get());
+    SyncEngineInitializer* initializer =
+        new SyncEngineInitializer(
+            context_.get(),
+            base::MessageLoopProxy::current(),
+            context_->GetDriveService(),
+            database_dir_.path(),
+            in_memory_env_.get());
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
-    initializer.RunSequential(CreateResultReceiver(&status));
+    sync_task_manager_->ScheduleSyncTask(
+        FROM_HERE,
+        scoped_ptr<SyncTask>(initializer),
+        SyncTaskManager::PRIORITY_MED,
+        base::Bind(&RemoteToLocalSyncerTest::DidInitializeMetadataDatabase,
+                   base::Unretained(this),
+                   initializer, &status));
+
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(SYNC_STATUS_OK, status);
-    context_->SetMetadataDatabase(initializer.PassMetadataDatabase());
   }
 
+  void DidInitializeMetadataDatabase(SyncEngineInitializer* initializer,
+                                     SyncStatusCode* status_out,
+                                     SyncStatusCode status) {
+    *status_out = status;
+    context_->SetMetadataDatabase(initializer->PassMetadataDatabase());
+  }
+
+
   void RegisterApp(const std::string& app_id,
                    const std::string& app_root_folder_id) {
     SyncStatusCode status = SYNC_STATUS_FAILED;
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
index 5d3d995..89a05092 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
@@ -13,6 +13,8 @@
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
@@ -25,10 +27,6 @@ namespace {
 ////////////////////////////////////////////////////////////////////////////////
 // Functions below are for wrapping the access to legacy GData WAPI classes.
 
-bool IsDeleted(const google_apis::ResourceEntry& entry) {
-  return entry.deleted();
-}
-
 bool HasNoParents(const google_apis::ResourceEntry& entry) {
   return !entry.GetLinkByType(google_apis::Link::LINK_PARENT);
 }
@@ -52,24 +50,10 @@ bool LessOnCreationTime(const google_apis::ResourceEntry& left,
   return left.published_time() < right.published_time();
 }
 
-// Posts a request to continue listing.  Returns false if the list doesn't need
-// listing anymore.
-bool GetRemainingFileList(
-    google_apis::CancelCallback* cancel_callback,
-    drive::DriveServiceInterface* api_service,
-    const google_apis::ResourceList& resource_list,
-    const google_apis::GetResourceListCallback& callback) {
-  GURL next_url;
-  if (!resource_list.GetNextFeedURL(&next_url))
-    return false;
-
-  *cancel_callback = api_service->GetRemainingFileList(next_url, callback);
-  return true;
-}
-
-std::string GetID(const google_apis::ResourceEntry& entry) {
-  return entry.resource_id();
-}
+typedef base::Callback<void(scoped_ptr<SyncTaskToken> token,
+                            google_apis::GDataErrorCode error,
+                            scoped_ptr<google_apis::ResourceList> resources)>
+    TokenAndResourceListCallback;
 
 ScopedVector<google_apis::FileResource> ConvertResourceEntriesToFileResources(
     const ScopedVector<google_apis::ResourceEntry>& entries) {
@@ -113,21 +97,21 @@ SyncEngineInitializer::~SyncEngineInitializer() {
     cancel_callback_.Run();
 }
 
-void SyncEngineInitializer::RunSequential(const SyncStatusCallback& callback) {
+void SyncEngineInitializer::Run(scoped_ptr<SyncTaskToken> token) {
   util::Log(logging::LOG_VERBOSE, FROM_HERE, "[Initialize] Start.");
 
   // The metadata seems to have been already initialized. Just return with OK.
   if (sync_context_ && sync_context_->GetMetadataDatabase()) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Already initialized.");
-    callback.Run(SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   MetadataDatabase::Create(
       task_runner_.get(), database_path_, env_override_,
       base::Bind(&SyncEngineInitializer::DidCreateMetadataDatabase,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 scoped_ptr<MetadataDatabase> SyncEngineInitializer::PassMetadataDatabase() {
@@ -135,13 +119,13 @@ scoped_ptr<MetadataDatabase> SyncEngineInitializer::PassMetadataDatabase() {
 }
 
 void SyncEngineInitializer::DidCreateMetadataDatabase(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status,
     scoped_ptr<MetadataDatabase> instance) {
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to initialize MetadataDatabase.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
@@ -150,23 +134,23 @@ void SyncEngineInitializer::DidCreateMetadataDatabase(
   if (metadata_database_->HasSyncRoot()) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Found local cache of sync-root.");
-    callback.Run(SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
-  GetAboutResource(callback);
+  GetAboutResource(token.Pass());
 }
 
 void SyncEngineInitializer::GetAboutResource(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   set_used_network(true);
   drive_service_->GetAboutResource(
       base::Bind(&SyncEngineInitializer::DidGetAboutResource,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidGetAboutResource(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::AboutResource> about_resource) {
   cancel_callback_.Reset();
@@ -175,7 +159,7 @@ void SyncEngineInitializer::DidGetAboutResource(
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to get AboutResource.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
@@ -184,14 +168,14 @@ void SyncEngineInitializer::DidGetAboutResource(
   largest_change_id_ = about_resource->largest_change_id();
 
   DCHECK(!root_folder_id_.empty());
-  FindSyncRoot(callback);
+  FindSyncRoot(token.Pass());
 }
 
-void SyncEngineInitializer::FindSyncRoot(const SyncStatusCallback& callback) {
+void SyncEngineInitializer::FindSyncRoot(scoped_ptr<SyncTaskToken> token) {
   if (find_sync_root_retry_count_++ >= kMaxRetry) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Reached max retry count.");
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -201,11 +185,11 @@ void SyncEngineInitializer::FindSyncRoot(const SyncStatusCallback& callback) {
       std::string(),  // parent_folder_id
       base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidFindSyncRoot(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceList> resource_list) {
   cancel_callback_.Reset();
@@ -214,7 +198,7 @@ void SyncEngineInitializer::DidFindSyncRoot(
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to find sync root.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
@@ -222,7 +206,7 @@ void SyncEngineInitializer::DidFindSyncRoot(
     NOTREACHED();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Got invalid resource list.");
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -234,7 +218,7 @@ void SyncEngineInitializer::DidFindSyncRoot(
     google_apis::ResourceEntry* entry = *itr;
 
     // Ignore deleted folder.
-    if (IsDeleted(*entry))
+    if (entry->deleted())
       continue;
 
     // Pick an orphaned folder or a direct child of the root folder and
@@ -251,28 +235,30 @@ void SyncEngineInitializer::DidFindSyncRoot(
 
   set_used_network(true);
   // If there are more results, retrieve them.
-  if (GetRemainingFileList(
-          &cancel_callback_,
-          drive_service_, *resource_list,
-          base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     callback)))
+  GURL next_url;
+  if (resource_list->GetNextFeedURL(&next_url)) {
+    cancel_callback_ = drive_service_->GetRemainingFileList(
+        next_url,
+        base::Bind(&SyncEngineInitializer::DidFindSyncRoot,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Passed(&token)));
     return;
+  }
 
   if (!sync_root_folder_) {
-    CreateSyncRoot(callback);
+    CreateSyncRoot(token.Pass());
     return;
   }
 
   if (!HasNoParents(*sync_root_folder_)) {
-    DetachSyncRoot(callback);
+    DetachSyncRoot(token.Pass());
     return;
   }
 
-  ListAppRootFolders(callback);
+  ListAppRootFolders(token.Pass());
 }
 
-void SyncEngineInitializer::CreateSyncRoot(const SyncStatusCallback& callback) {
+void SyncEngineInitializer::CreateSyncRoot(scoped_ptr<SyncTaskToken> token) {
   DCHECK(!sync_root_folder_);
   set_used_network(true);
   cancel_callback_ = drive_service_->AddNewDirectory(
@@ -280,11 +266,11 @@ void SyncEngineInitializer::CreateSyncRoot(const SyncStatusCallback& callback) {
       drive::DriveServiceInterface::AddNewDirectoryOptions(),
       base::Bind(&SyncEngineInitializer::DidCreateSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidCreateSyncRoot(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceEntry> entry) {
   DCHECK(!sync_root_folder_);
@@ -294,25 +280,25 @@ void SyncEngineInitializer::DidCreateSyncRoot(
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to create sync root.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
-  FindSyncRoot(callback);
+  FindSyncRoot(token.Pass());
 }
 
-void SyncEngineInitializer::DetachSyncRoot(const SyncStatusCallback& callback) {
+void SyncEngineInitializer::DetachSyncRoot(scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   set_used_network(true);
   cancel_callback_ = drive_service_->RemoveResourceFromDirectory(
-      root_folder_id_, GetID(*sync_root_folder_),
+      root_folder_id_, sync_root_folder_->resource_id(),
       base::Bind(&SyncEngineInitializer::DidDetachSyncRoot,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidDetachSyncRoot(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error) {
   cancel_callback_.Reset();
 
@@ -320,26 +306,26 @@ void SyncEngineInitializer::DidDetachSyncRoot(
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to detach sync root.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
-  ListAppRootFolders(callback);
+  ListAppRootFolders(token.Pass());
 }
 
 void SyncEngineInitializer::ListAppRootFolders(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   set_used_network(true);
   cancel_callback_ = drive_service_->GetResourceListInDirectory(
-      GetID(*sync_root_folder_),
+      sync_root_folder_->resource_id(),
       base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidListAppRootFolders(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceList> resource_list) {
   cancel_callback_.Reset();
@@ -348,7 +334,7 @@ void SyncEngineInitializer::DidListAppRootFolders(
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to get initial app-root folders.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
@@ -356,7 +342,7 @@ void SyncEngineInitializer::DidListAppRootFolders(
     NOTREACHED();
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Got invalid initial app-root list.");
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
@@ -367,19 +353,20 @@ void SyncEngineInitializer::DidListAppRootFolders(
   new_entries->weak_clear();
 
   set_used_network(true);
-  if (GetRemainingFileList(
-          &cancel_callback_,
-          drive_service_,
-          *resource_list,
-          base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
-                     weak_ptr_factory_.GetWeakPtr(), callback)))
+  GURL next_url;
+  if (resource_list->GetNextFeedURL(&next_url)) {
+    cancel_callback_ = drive_service_->GetRemainingFileList(
+        next_url,
+        base::Bind(&SyncEngineInitializer::DidListAppRootFolders,
+                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
     return;
+  }
 
-  PopulateDatabase(callback);
+  PopulateDatabase(token.Pass());
 }
 
 void SyncEngineInitializer::PopulateDatabase(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_root_folder_);
   metadata_database_->PopulateInitialData(
       largest_change_id_,
@@ -387,24 +374,23 @@ void SyncEngineInitializer::PopulateDatabase(
           *sync_root_folder_),
       ConvertResourceEntriesToFileResources(app_root_folders_),
       base::Bind(&SyncEngineInitializer::DidPopulateDatabase,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void SyncEngineInitializer::DidPopulateDatabase(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Initialize] Failed to populate initial data"
               " to MetadataDatabase.");
-    callback.Run(status);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), status);
     return;
   }
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Initialize] Completed successfully.");
-  callback.Run(SYNC_STATUS_OK);
+  SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
 }
 
 }  // namespace drive_backend
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h
index 39e8f22..a1b86a4 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.h
@@ -64,7 +64,7 @@ class SyncEngineContext;
 //  - Populate database with the largest change ID, the sync-root folder and
 //    its contents.
 //
-class SyncEngineInitializer : public SequentialSyncTask {
+class SyncEngineInitializer : public SyncTask {
  public:
   SyncEngineInitializer(SyncEngineContext* sync_context,
                         base::SequencedTaskRunner* task_runner,
@@ -72,40 +72,40 @@ class SyncEngineInitializer : public SequentialSyncTask {
                         const base::FilePath& database_path,
                         leveldb::Env* env_override);
   virtual ~SyncEngineInitializer();
-  virtual void RunSequential(const SyncStatusCallback& callback) OVERRIDE;
+  virtual void Run(scoped_ptr<SyncTaskToken> token) OVERRIDE;
 
   scoped_ptr<MetadataDatabase> PassMetadataDatabase();
 
  private:
   typedef base::Callback<void(const SyncStatusCallback& callback)> Task;
 
-  void DidCreateMetadataDatabase(const SyncStatusCallback& callback,
+  void DidCreateMetadataDatabase(scoped_ptr<SyncTaskToken> token,
                                  SyncStatusCode status,
                                  scoped_ptr<MetadataDatabase> instance);
 
-  void GetAboutResource(const SyncStatusCallback& callback);
+  void GetAboutResource(scoped_ptr<SyncTaskToken> token);
   void DidGetAboutResource(
-      const SyncStatusCallback& callback,
+      scoped_ptr<SyncTaskToken> token,
       google_apis::GDataErrorCode error,
       scoped_ptr<google_apis::AboutResource> about_resource);
-  void FindSyncRoot(const SyncStatusCallback& callback);
-  void DidFindSyncRoot(const SyncStatusCallback& callback,
+  void FindSyncRoot(scoped_ptr<SyncTaskToken> token);
+  void DidFindSyncRoot(scoped_ptr<SyncTaskToken> token,
                        google_apis::GDataErrorCode error,
                        scoped_ptr<google_apis::ResourceList> resource_list);
-  void CreateSyncRoot(const SyncStatusCallback& callback);
-  void DidCreateSyncRoot(const SyncStatusCallback& callback,
+  void CreateSyncRoot(scoped_ptr<SyncTaskToken> token);
+  void DidCreateSyncRoot(scoped_ptr<SyncTaskToken> token,
                          google_apis::GDataErrorCode error,
                          scoped_ptr<google_apis::ResourceEntry> entry);
-  void DetachSyncRoot(const SyncStatusCallback& callback);
-  void DidDetachSyncRoot(const SyncStatusCallback& callback,
+  void DetachSyncRoot(scoped_ptr<SyncTaskToken> token);
+  void DidDetachSyncRoot(scoped_ptr<SyncTaskToken> token,
                          google_apis::GDataErrorCode error);
-  void ListAppRootFolders(const SyncStatusCallback& callback);
+  void ListAppRootFolders(scoped_ptr<SyncTaskToken> token);
   void DidListAppRootFolders(
-      const SyncStatusCallback& callback,
+      scoped_ptr<SyncTaskToken> token,
       google_apis::GDataErrorCode error,
       scoped_ptr<google_apis::ResourceList> resource_list);
-  void PopulateDatabase(const SyncStatusCallback& callback);
-  void DidPopulateDatabase(const SyncStatusCallback& callback,
+  void PopulateDatabase(scoped_ptr<SyncTaskToken> token);
+  void DidPopulateDatabase(scoped_ptr<SyncTaskToken> token,
                            SyncStatusCode status);
 
   SyncEngineContext* sync_context_;  // Not owned.
diff --git a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc
index 54974776..58d8743 100644
--- a/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc
+++ b/chrome/browser/sync_file_system/drive_backend/sync_engine_initializer_unittest.cc
@@ -13,6 +13,7 @@
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_test_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 #include "chrome/browser/sync_file_system/sync_file_system_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/drive/drive_api_parser.h"
@@ -48,10 +49,15 @@ class SyncEngineInitializerTest : public testing::Test {
         "sync_file_system/account_metadata.json"));
     ASSERT_TRUE(fake_drive_service_.LoadResourceListForWapi(
         "gdata/empty_feed.json"));
+
+    sync_task_manager_.reset(new SyncTaskManager(
+        base::WeakPtr<SyncTaskManager::Client>(),
+        1 /* maximum_parallel_task */));
+    sync_task_manager_->Initialize(SYNC_STATUS_OK);
   }
 
   virtual void TearDown() OVERRIDE {
-    initializer_.reset();
+    sync_task_manager_.reset();
     metadata_database_.reset();
     base::RunLoop().RunUntilIdle();
   }
@@ -61,21 +67,33 @@ class SyncEngineInitializerTest : public testing::Test {
   }
 
   SyncStatusCode RunInitializer() {
-    initializer_.reset(new SyncEngineInitializer(
-        NULL,
-        base::MessageLoopProxy::current(),
-        &fake_drive_service_,
-        database_path(),
-        in_memory_env_.get()));
+    SyncEngineInitializer* initializer =
+        new SyncEngineInitializer(
+            NULL,
+            base::MessageLoopProxy::current(),
+            &fake_drive_service_,
+            database_path(),
+            in_memory_env_.get());
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
 
-    initializer_->RunSequential(CreateResultReceiver(&status));
-    base::RunLoop().RunUntilIdle();
+    sync_task_manager_->ScheduleSyncTask(
+        FROM_HERE,
+        scoped_ptr<SyncTask>(initializer),
+        SyncTaskManager::PRIORITY_MED,
+        base::Bind(&SyncEngineInitializerTest::DidRunInitializer,
+                   base::Unretained(this), initializer, &status));
 
-    metadata_database_ = initializer_->PassMetadataDatabase();
+    base::RunLoop().RunUntilIdle();
     return status;
   }
 
+  void DidRunInitializer(SyncEngineInitializer* initializer,
+                         SyncStatusCode* status_out,
+                         SyncStatusCode status) {
+    *status_out = status;
+    metadata_database_ = initializer->PassMetadataDatabase();
+  }
+
   SyncStatusCode PopulateDatabase(
       const google_apis::FileResource& sync_root,
       const google_apis::FileResource** app_roots,
@@ -201,8 +219,8 @@ class SyncEngineInitializerTest : public testing::Test {
   scoped_ptr<leveldb::Env> in_memory_env_;
   drive::FakeDriveService fake_drive_service_;
 
-  scoped_ptr<SyncEngineInitializer> initializer_;
   scoped_ptr<MetadataDatabase> metadata_database_;
+  scoped_ptr<SyncTaskManager> sync_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncEngineInitializerTest);
 };