[SyncFS] Make SyncEngineInitializer run as a background task (3/3)

chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc

Index: chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc
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 5d3d9956eb322495bf3222708e4353b542cd662c..89a05092e2f12057e7b68d18cbf7048601de4407 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