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

chrome/browser/sync_file_system/drive_backend/sync_engine_initializer.cc

 // Copyright 2013 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_engine_initializer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "chrome/browser/drive/drive_api_service.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_constants.h"
 #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"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 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);
 }
 
 bool HasFolderAsParent(const google_apis::ResourceEntry& entry,
                        const std::string& parent_id) {
   const ScopedVector<google_apis::Link>& links = entry.links();
   for (ScopedVector<google_apis::Link>::const_iterator itr = links.begin();
        itr != links.end(); ++itr) {
     const google_apis::Link& link = **itr;
     if (link.type() != google_apis::Link::LINK_PARENT)
       continue;
     if (drive::util::ExtractResourceIdFromUrl(link.href()) == parent_id)
       return true;
   }
   return false;
 }
 
 bool LessOnCreationTime(const google_apis::ResourceEntry& left,
                         const google_apis::ResourceEntry& right) {
   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) {
   ScopedVector<google_apis::FileResource> resources;
   for (ScopedVector<google_apis::ResourceEntry>::const_iterator itr =
            entries.begin();
        itr != entries.end();
        ++itr) {
     resources.push_back(
         drive::util::ConvertResourceEntryToFileResource(
@@ skipping 23 matching lines @@
       weak_ptr_factory_(this) {
   DCHECK(task_runner);
   DCHECK(drive_service_);
 }
 
 SyncEngineInitializer::~SyncEngineInitializer() {
   if (!cancel_callback_.is_null())
     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() {
   return metadata_database_.Pass();
 }
 
 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;
   }
 
   DCHECK(instance);
   metadata_database_ = instance.Pass();
   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();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   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;
   }
 
   DCHECK(about_resource);
   root_folder_id_ = about_resource->root_folder_id();
   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;
   }
 
   set_used_network(true);
   cancel_callback_ = drive_service_->SearchByTitle(
       kSyncRootFolderTitle,
       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();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   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;
   }
 
   if (!resource_list) {
     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;
   }
 
   ScopedVector<google_apis::ResourceEntry>* entries =
       resource_list->mutable_entries();
   for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
            entries->begin();
        itr != entries->end(); ++itr) {
     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
     // ignore others.
     DCHECK(!root_folder_id_.empty());
     if (!HasNoParents(*entry) && !HasFolderAsParent(*entry, root_folder_id_))
       continue;
 
     if (!sync_root_folder_ || LessOnCreationTime(*entry, *sync_root_folder_)) {
       sync_root_folder_.reset(entry);
       *itr = NULL;
     }
   }
 
   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(
       root_folder_id_, kSyncRootFolderTitle,
       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_);
   cancel_callback_.Reset();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   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();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   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();
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   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;
   }
 
   if (!resource_list) {
     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;
   }
 
   ScopedVector<google_apis::ResourceEntry>* new_entries =
       resource_list->mutable_entries();
   app_root_folders_.insert(app_root_folders_.end(),
                            new_entries->begin(), new_entries->end());
   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_,
       *drive::util::ConvertResourceEntryToFileResource(
           *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
 }  // namespace sync_file_system