[SyncFS] Make MetadataDatabase operations synchronous

chrome/browser/sync_file_system/drive_backend/local_to_remote_syncer.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/local_to_remote_syncer.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 352 matching lines @@
     return;
   }
 
   const FileDetails& remote_details = remote_file_metadata.details();
   base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   if (!remote_details.missing() &&
       remote_details.file_kind() == FILE_KIND_FOLDER &&
       remote_details.title() == title.AsUTF8Unsafe() &&
       HasFileAsParent(remote_details,
                       remote_parent_folder_tracker_->file_id())) {
-
     MoveToBackground(
         base::Bind(&LocalToRemoteSyncer::UpdateTrackerForReusedFolder,
                    weak_ptr_factory_.GetWeakPtr(),
                    remote_details),
         token.Pass());
     return;
   }
 
   MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                               weak_ptr_factory_.GetWeakPtr()),
                    token.Pass());
 }
 
 void LocalToRemoteSyncer::UpdateTrackerForReusedFolder(
     const FileDetails& details,
     scoped_ptr<SyncTaskToken> token) {
-  metadata_database()->UpdateTracker(
-      remote_file_tracker_->tracker_id(), details,
-      base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&token)));
+  SyncStatusCode status = metadata_database()->UpdateTracker(
+      remote_file_tracker_->tracker_id(), details);
+  SyncCompleted(token.Pass(), status);
 }
 
 void LocalToRemoteSyncer::HandleExistingRemoteFile(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
   DCHECK(!remote_file_tracker_->dirty());
   DCHECK(remote_file_tracker_->active());
   DCHECK(remote_file_tracker_->has_synced_details());
 
   if (local_is_missing_) {
@@ skipping 70 matching lines @@
     SyncCompleted(token.Pass(), status);
     return;
   }
 
   // Handle NOT_FOUND case as SUCCESS case.
   // For PRECONDITION / CONFLICT case, the remote file is modified since the
   // last sync completed.  As our policy for deletion-modification conflict
   // resolution, ignore the local deletion.
   if (status == SYNC_STATUS_OK ||
       error == google_apis::HTTP_NOT_FOUND) {
-    metadata_database()->UpdateByDeletedRemoteFile(
-        remote_file_tracker_->file_id(),
-        base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
+    SyncStatusCode status = metadata_database()->UpdateByDeletedRemoteFile(
+        remote_file_tracker_->file_id());
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   SyncCompleted(token.Pass(), SYNC_STATUS_OK);
 }
 
 void LocalToRemoteSyncer::UploadExistingFile(scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
   DCHECK(remote_file_tracker_->has_synced_details());
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
@@ skipping 45 matching lines @@
     return;
   }
 
   if (!entry) {
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   DCHECK(entry);
-  metadata_database()->UpdateByFileResource(
-      *entry,
-      base::Bind(&LocalToRemoteSyncer::DidUpdateDatabaseForUploadExistingFile,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&token)));
+  status = metadata_database()->UpdateByFileResource(*entry);
+  DidUpdateDatabaseForUploadExistingFile(token.Pass(), status);

[peria, 2014/09/10 00:24:15]

Expand DidUpdateDatabaseForUploadExistingFile() here.

[tzik, 2014/09/10 00:56:54]

ditto

 }
 
 void LocalToRemoteSyncer::DidUpdateDatabaseForUploadExistingFile(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(token.Pass(), status);
     return;
   }
 
   FileMetadata file;
   if (!metadata_database()->FindFileByFileID(
           remote_file_tracker_->file_id(), &file)) {
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   const FileDetails& details = file.details();
   base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   if (!details.missing() &&
       details.file_kind() == FILE_KIND_FILE &&
       details.title() == title.AsUTF8Unsafe() &&
       HasFileAsParent(details,
                       remote_parent_folder_tracker_->file_id())) {
-    metadata_database()->UpdateTracker(
-        remote_file_tracker_->tracker_id(),
-        file.details(),
-        base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Passed(&token)));
+    SyncStatusCode status = metadata_database()->UpdateTracker(
+        remote_file_tracker_->tracker_id(), file.details());
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
 }
 
 void LocalToRemoteSyncer::UpdateRemoteMetadata(
     const std::string& file_id,
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
 
   drive_service()->GetFileResource(
       file_id,
       base::Bind(&LocalToRemoteSyncer::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
                  file_id, base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::DidGetRemoteMetadata(
     const std::string& file_id,
     scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   if (error == google_apis::HTTP_NOT_FOUND) {
     retry_on_success_ = true;
-    metadata_database()->UpdateByDeletedRemoteFile(
-        file_id,
-        base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Passed(&token)));
+    SyncStatusCode status =
+        metadata_database()->UpdateByDeletedRemoteFile(file_id);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(token.Pass(), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   retry_on_success_ = true;
-  metadata_database()->UpdateByFileResource(
-      *entry,
-      base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&token)));
+  status = metadata_database()->UpdateByFileResource(*entry);
+  SyncCompleted(token.Pass(), status);
 }
 
 void LocalToRemoteSyncer::UploadNewFile(scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   sync_action_ = SYNC_ACTION_ADDED;
   base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   drive_uploader()->UploadNewFile(
       remote_parent_folder_tracker_->file_id(),
       local_path_,
@@ skipping 19 matching lines @@
     SyncCompleted(token.Pass(), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
-  metadata_database()->ReplaceActiveTrackerWithNewResource(
-      remote_parent_folder_tracker_->tracker_id(), *entry,
-      base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(&token)));
+  status = metadata_database()->ReplaceActiveTrackerWithNewResource(
+      remote_parent_folder_tracker_->tracker_id(), *entry);
+  SyncCompleted(token.Pass(), status);
 }
 
 void LocalToRemoteSyncer::CreateRemoteFolder(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   sync_action_ = SYNC_ACTION_ADDED;
 
   DCHECK(!folder_creator_);
@@ skipping 13 matching lines @@
     SyncStatusCode status) {
   if (status == SYNC_FILE_ERROR_NOT_FOUND)
     needs_remote_change_listing_ = true;
 
   scoped_ptr<FolderCreator> deleter = folder_creator_.Pass();
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(token.Pass(), status);
     return;
   }
 
+  status = SYNC_STATUS_FAILED;
   MetadataDatabase::ActivationStatus activation_status =
       metadata_database()->TryActivateTracker(
           remote_parent_folder_tracker_->tracker_id(),
-          file_id,
-          base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     base::Passed(token.Pass())));
+          file_id, &status);
   switch (activation_status) {
     case MetadataDatabase::ACTIVATION_PENDING:
-      // The task will be finalized by the callback passed to MetadataDatabase
-      // in this case.
+      SyncCompleted(token.Pass(), status);
       return;
     case MetadataDatabase::ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER:
       // The activation failed due to another tracker that has another parent.
       // Detach the folder from the current parent to avoid using this folder as
       // active folder.
       drive_service()->RemoveResourceFromDirectory(
           remote_parent_folder_tracker_->file_id(), file_id,
           base::Bind(&LocalToRemoteSyncer::DidDetachResourceForCreationConflict,
                      weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
       return;
@@ skipping 31 matching lines @@
   set_used_network(true);
   return sync_context_->GetDriveUploader();
 }
 
 MetadataDatabase* LocalToRemoteSyncer::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system