[SyncFS] Make MetadataDatabase operations synchronous

chrome/browser/sync_file_system/drive_backend/metadata_database.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/metadata_database.h"
 
 #include <algorithm>
 #include <stack>
 
 #include "base/bind.h"
-#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/scoped_vector.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 19 matching lines @@
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 // Command line flag to disable on-disk indexing.
 const char kDisableMetadataDatabaseOnDisk[] = "disable-syncfs-on-disk-indexing";
 
-void EmptyStatusCallback(SyncStatusCode status) {}
-
 std::string FileKindToString(FileKind file_kind) {
   switch (file_kind) {
     case FILE_KIND_UNSUPPORTED:
       return "unsupported";
     case FILE_KIND_FILE:
       return "file";
     case FILE_KIND_FOLDER:
       return "folder";
   }
 
@@ skipping 450 matching lines @@
     MarkTrackersDirtyByPath(parent_tracker_id, title, index);
 
   if (index->GetFileTrackerIDsByFileID(file_id).empty()) {
     index->RemoveFileMetadata(file_id);
   }
 }
 
 }  // namespace
 
 // static
-void MetadataDatabase::Create(
+scoped_ptr<MetadataDatabase> MetadataDatabase::Create(
     const base::FilePath& database_path,
     leveldb::Env* env_override,
-    const CreateCallback& callback) {
+    SyncStatusCode* status_out) {
   bool enable_on_disk_index = !CommandLine::ForCurrentProcess()->HasSwitch(
       kDisableMetadataDatabaseOnDisk);
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(database_path,
                            enable_on_disk_index,
                            env_override));
 
   SyncStatusCode status = metadata_database->Initialize();
   if (status == SYNC_DATABASE_ERROR_FAILED) {
     // Delete the previous instance to avoid creating a LevelDB instance for
     // the same path.
     metadata_database.reset();
 
     metadata_database.reset(
         new MetadataDatabase(database_path,
                              enable_on_disk_index,
                              env_override));
     status = metadata_database->Initialize();
   }
 
   if (status != SYNC_STATUS_OK)
     metadata_database.reset();
 
-  callback.Run(status, metadata_database.Pass());
+  *status_out = status;
+  return metadata_database.Pass();
 }
 
 // static
 SyncStatusCode MetadataDatabase::CreateForTesting(
     scoped_ptr<LevelDBWrapper> db,
     bool enable_on_disk_index,
     scoped_ptr<MetadataDatabase>* metadata_database_out) {
   scoped_ptr<MetadataDatabase> metadata_database(
       new MetadataDatabase(base::FilePath(),
                            enable_on_disk_index,
@@ skipping 34 matching lines @@
 
 void MetadataDatabase::UpdateLargestKnownChangeID(int64 change_id) {
   if (largest_known_change_id_ < change_id)
     largest_known_change_id_ = change_id;
 }
 
 bool MetadataDatabase::HasSyncRoot() const {
   return index_->GetSyncRootTrackerID() != kInvalidTrackerID;
 }
 
-void MetadataDatabase::PopulateInitialData(
+SyncStatusCode MetadataDatabase::PopulateInitialData(
     int64 largest_change_id,
     const google_apis::FileResource& sync_root_folder,
-    const ScopedVector<google_apis::FileResource>& app_root_folders,
-    const SyncStatusCallback& callback) {
+    const ScopedVector<google_apis::FileResource>& app_root_folders) {
   index_->SetLargestChangeID(largest_change_id);
   UpdateLargestKnownChangeID(largest_change_id);
 
   AttachSyncRoot(sync_root_folder);
   for (size_t i = 0; i < app_root_folders.size(); ++i)
     AttachInitialAppRoot(*app_root_folders[i]);
 
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
 bool MetadataDatabase::IsAppEnabled(const std::string& app_id) const {
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   if (tracker_id == kInvalidTrackerID)
     return false;
 
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker))
     return false;
   return tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
 }
 
-void MetadataDatabase::RegisterApp(const std::string& app_id,
-                                   const std::string& folder_id,
-                                   const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::RegisterApp(const std::string& app_id,
+                                   const std::string& folder_id) {
   if (index_->GetAppRootTracker(app_id)) {
     // The app-root is already registered.
-    callback.Run(SYNC_STATUS_OK);
-    return;
+    return SYNC_STATUS_OK;
   }
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (trackers.empty()) {
-    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
-    return;
+    return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (trackers.has_active()) {
     // The folder is tracked by another tracker.
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Failed to register App for %s", app_id.c_str());
-    callback.Run(SYNC_STATUS_HAS_CONFLICT);
-    return;
+    return SYNC_STATUS_HAS_CONFLICT;
   }
 
   int64 sync_root_tracker_id = index_->GetSyncRootTrackerID();
   if (!sync_root_tracker_id) {
     util::Log(logging::LOG_WARNING, FROM_HERE,
               "Sync-root needs to be set up before registering app-root");
-    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
-    return;
+    return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!FilterFileTrackersByParent(index_.get(), trackers,
                                   sync_root_tracker_id, tracker.get())) {
-    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
-    return;
+    return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   tracker->set_app_id(app_id);
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   tracker->set_active(true);
   tracker->set_needs_folder_listing(true);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(tracker.Pass());
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::DisableApp(const std::string& app_id,
-                                  const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::DisableApp(const std::string& app_id) {
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
-    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
-    return;
+    return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT) {
-    callback.Run(SYNC_STATUS_OK);
-    return;
+    return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   // Keep the app-root tracker active (but change the tracker_kind) so that
   // other conflicting trackers won't become active.
   tracker->set_tracker_kind(TRACKER_KIND_DISABLED_APP_ROOT);
 
   index_->StoreFileTracker(tracker.Pass());
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::EnableApp(const std::string& app_id,
-                                 const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::EnableApp(const std::string& app_id) {
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get())) {
-    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
-    return;
+    return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   if (tracker->tracker_kind() == TRACKER_KIND_APP_ROOT) {
-    callback.Run(SYNC_STATUS_OK);
-    return;
+    return SYNC_STATUS_OK;
   }
 
   DCHECK_EQ(TRACKER_KIND_DISABLED_APP_ROOT, tracker->tracker_kind());
   DCHECK(tracker->active());
 
   tracker->set_tracker_kind(TRACKER_KIND_APP_ROOT);
   index_->StoreFileTracker(tracker.Pass());
 
   MarkTrackersDirtyRecursively(tracker_id, index_.get());
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::UnregisterApp(const std::string& app_id,
-                                     const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::UnregisterApp(const std::string& app_id) {
   int64 tracker_id = index_->GetAppRootTracker(app_id);
   scoped_ptr<FileTracker> tracker(new FileTracker);
   if (!index_->GetFileTracker(tracker_id, tracker.get()) ||
       tracker->tracker_kind() == TRACKER_KIND_REGULAR) {
-    callback.Run(SYNC_STATUS_OK);
-    return;
+    return SYNC_STATUS_OK;
   }
 
   RemoveAllDescendantTrackers(tracker_id, index_.get());
 
   tracker->clear_app_id();
   tracker->set_tracker_kind(TRACKER_KIND_REGULAR);
   tracker->set_active(false);
   tracker->set_dirty(true);
 
   index_->StoreFileTracker(tracker.Pass());
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
 bool MetadataDatabase::FindAppRootTracker(const std::string& app_id,
                                           FileTracker* tracker_out) const {
   int64 app_root_tracker_id = index_->GetAppRootTracker(app_id);
   if (!app_root_tracker_id)
     return false;
 
   if (tracker_out &&
       !index_->GetFileTracker(app_root_tracker_id, tracker_out)) {
@@ skipping 116 matching lines @@
       return true;
     }
 
     tracker_out->CopyFrom(tracker);
     *path_out = path_out->Append(components[i]);
   }
 
   return true;
 }
 
-void MetadataDatabase::UpdateByChangeList(
+SyncStatusCode MetadataDatabase::UpdateByChangeList(
     int64 largest_change_id,
-    ScopedVector<google_apis::ChangeResource> changes,
-    const SyncStatusCallback& callback) {
+    ScopedVector<google_apis::ChangeResource> changes) {
   DCHECK_LE(index_->GetLargestChangeID(), largest_change_id);
 
   for (size_t i = 0; i < changes.size(); ++i) {
     const google_apis::ChangeResource& change = *changes[i];
     if (HasNewerFileMetadata(change.file_id(), change.change_id()))
       continue;
 
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromChangeResource(change));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
 
   UpdateLargestKnownChangeID(largest_change_id);
   index_->SetLargestChangeID(largest_change_id);
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::UpdateByFileResource(
-    const google_apis::FileResource& resource,
-    const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::UpdateByFileResource(
+    const google_apis::FileResource& resource) {
   scoped_ptr<FileMetadata> metadata(
       CreateFileMetadataFromFileResource(
           GetLargestKnownChangeID(), resource));
   UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::UpdateByFileResourceList(
-    ScopedVector<google_apis::FileResource> resources,
-    const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::UpdateByFileResourceList(
+    ScopedVector<google_apis::FileResource> resources) {
   for (size_t i = 0; i < resources.size(); ++i) {
     scoped_ptr<FileMetadata> metadata(
         CreateFileMetadataFromFileResource(
             GetLargestKnownChangeID(), *resources[i]));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::UpdateByDeletedRemoteFile(
-    const std::string& file_id,
-    const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFile(
+    const std::string& file_id) {
   scoped_ptr<FileMetadata> metadata(
       CreateDeletedFileMetadata(GetLargestKnownChangeID(), file_id));
   UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                        UPDATE_TRACKER_FOR_UNSYNCED_FILE);
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::UpdateByDeletedRemoteFileList(
-    const FileIDList& file_ids,
-    const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::UpdateByDeletedRemoteFileList(
+    const FileIDList& file_ids) {
   for (FileIDList::const_iterator itr = file_ids.begin();
        itr != file_ids.end(); ++itr) {
     scoped_ptr<FileMetadata> metadata(
         CreateDeletedFileMetadata(GetLargestKnownChangeID(), *itr));
     UpdateByFileMetadata(FROM_HERE, metadata.Pass(),
                          UPDATE_TRACKER_FOR_UNSYNCED_FILE);
   }
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::ReplaceActiveTrackerWithNewResource(
+SyncStatusCode MetadataDatabase::ReplaceActiveTrackerWithNewResource(
     int64 parent_tracker_id,
-    const google_apis::FileResource& resource,
-    const SyncStatusCallback& callback) {
+    const google_apis::FileResource& resource) {
   DCHECK(!index_->GetFileMetadata(resource.file_id(), NULL));
   DCHECK(index_->GetFileTracker(parent_tracker_id, NULL));
 
   UpdateByFileMetadata(
       FROM_HERE,
       CreateFileMetadataFromFileResource(GetLargestKnownChangeID(), resource),
       UPDATE_TRACKER_FOR_SYNCED_FILE);
 
   DCHECK(index_->GetFileMetadata(resource.file_id(), NULL));
   DCHECK(!index_->GetFileTrackerIDsByFileID(resource.file_id()).has_active());
 
   TrackerIDSet same_path_trackers =
       index_->GetFileTrackerIDsByParentAndTitle(
           parent_tracker_id, resource.title());
   FileTracker to_be_activated;
   if (!FilterFileTrackersByFileID(index_.get(), same_path_trackers,
                                   resource.file_id(), &to_be_activated)) {
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
-    return;
+    return SYNC_STATUS_FAILED;
   }
 
   int64 tracker_id = to_be_activated.tracker_id();
   if (same_path_trackers.has_active()) {
     DeactivateFileTracker(same_path_trackers.active_tracker(),
                           MARK_ITSELF_DIRTY |
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
                           index_.get());
   }
 
   ActivateFileTracker(tracker_id, MARK_NOTHING_DIRTY, index_.get());
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::PopulateFolderByChildList(
+SyncStatusCode MetadataDatabase::PopulateFolderByChildList(
     const std::string& folder_id,
-    const FileIDList& child_file_ids,
-    const SyncStatusCallback& callback) {
+    const FileIDList& child_file_ids) {
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(folder_id);
   if (!trackers.has_active()) {
     // It's OK that there is no folder to populate its children.
     // Inactive folders should ignore their contents updates.
-    callback.Run(SYNC_STATUS_OK);
-    return;
+    return SYNC_STATUS_OK;
   }
 
   scoped_ptr<FileTracker> folder_tracker(new FileTracker);
   if (!index_->GetFileTracker(trackers.active_tracker(),
                               folder_tracker.get())) {
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
-    return;
+    return SYNC_STATUS_FAILED;
   }
 
   base::hash_set<std::string> children(child_file_ids.begin(),
                                        child_file_ids.end());
 
   std::vector<int64> known_children =
       index_->GetFileTrackerIDsByParent(folder_tracker->tracker_id());
   for (size_t i = 0; i < known_children.size(); ++i) {
     FileTracker tracker;
     if (!index_->GetFileTracker(known_children[i], &tracker)) {
       NOTREACHED();
       continue;
     }
     children.erase(tracker.file_id());
   }
 
   for (base::hash_set<std::string>::const_iterator itr = children.begin();
        itr != children.end(); ++itr)
     CreateTrackerForParentAndFileID(*folder_tracker, *itr);
   folder_tracker->set_needs_folder_listing(false);
   if (folder_tracker->dirty() && !ShouldKeepDirty(*folder_tracker))
     folder_tracker->set_dirty(false);
   index_->StoreFileTracker(folder_tracker.Pass());
 
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
-void MetadataDatabase::UpdateTracker(int64 tracker_id,
-                                     const FileDetails& updated_details,
-                                     const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::UpdateTracker(
+    int64 tracker_id,
+    const FileDetails& updated_details) {
   FileTracker tracker;
   if (!index_->GetFileTracker(tracker_id, &tracker)) {
-    callback.Run(SYNC_DATABASE_ERROR_NOT_FOUND);
-    return;
+    return SYNC_DATABASE_ERROR_NOT_FOUND;
   }
 
   // Check if the tracker is to be deleted.
   if (updated_details.missing()) {
     FileMetadata metadata;
     if (!index_->GetFileMetadata(tracker.file_id(), &metadata) ||
         metadata.details().missing()) {
       // Both the tracker and metadata have the missing flag, now it's safe to
       // delete the |tracker|.
       RemoveFileTracker(tracker_id,
                         MARK_SAME_FILE_ID_TRACKERS_DIRTY |
                         MARK_SAME_PATH_TRACKERS_DIRTY,
                         index_.get());
-      WriteToDatabase(callback);
-      return;
+      return WriteToDatabase();
     }
   }
 
   // Sync-root deletion should be handled separately by SyncEngine.
   DCHECK(tracker_id != GetSyncRootTrackerID() ||
          (tracker.has_synced_details() &&
           tracker.synced_details().title() == updated_details.title() &&
           !updated_details.missing()));
 
   if (tracker_id != GetSyncRootTrackerID()) {
     // Check if the tracker's parent is still in |parent_tracker_ids|.
     // If not, there should exist another tracker for the new parent, so delete
     // old tracker.
     FileTracker parent_tracker;
     index_->GetFileTracker(tracker.parent_tracker_id(), &parent_tracker);
 
     if (!HasFileAsParent(updated_details, parent_tracker.file_id())) {
       RemoveFileTracker(tracker.tracker_id(),
                         MARK_SAME_PATH_TRACKERS_DIRTY,
                         index_.get());
-      WriteToDatabase(callback);
-      return;
+      return WriteToDatabase();
     }
 
     if (tracker.has_synced_details()) {
       // Check if the tracker was retitled.  If it was, there should exist
       // another tracker for the new title, so delete the tracker being updated.
       if (tracker.synced_details().title() != updated_details.title()) {
         RemoveFileTracker(tracker.tracker_id(),
                           MARK_SAME_FILE_ID_TRACKERS_DIRTY,
                           index_.get());
-        WriteToDatabase(callback);
-        return;
+        return WriteToDatabase();
       }
     } else {
       // Check if any other tracker exists has the same parent, title and
       // file_id to the updated tracker.  If it exists, delete the tracker being
       // updated.
       if (FilterFileTrackersByFileID(
               index_.get(),
               index_->GetFileTrackerIDsByParentAndTitle(
                   parent_tracker.tracker_id(),
                   updated_details.title()),
               tracker.file_id(),
               NULL)) {
         RemoveFileTracker(tracker.tracker_id(),
                           MARK_NOTHING_DIRTY,
                           index_.get());
-        WriteToDatabase(callback);
-        return;
+        return WriteToDatabase();
       }
     }
   }
 
   scoped_ptr<FileTracker> updated_tracker = CloneFileTracker(&tracker);
   *updated_tracker->mutable_synced_details() = updated_details;
 
   bool should_promote = false;
 
   // Activate the tracker if:
   //   - There is no active tracker that tracks |tracker->file_id()|.
   //   - There is no active tracker that has the same |parent| and |title|.
   if (!tracker.active() && CanActivateTracker(tracker)) {
     updated_tracker->set_active(true);
     updated_tracker->set_dirty(true);
     updated_tracker->set_needs_folder_listing(
         tracker.synced_details().file_kind() == FILE_KIND_FOLDER);
     should_promote = true;
   } else if (tracker.dirty() && !ShouldKeepDirty(tracker)) {
     updated_tracker->set_dirty(false);
   }
   index_->StoreFileTracker(updated_tracker.Pass());
   if (should_promote)
     index_->PromoteDemotedDirtyTracker(tracker_id);
 
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
 MetadataDatabase::ActivationStatus MetadataDatabase::TryActivateTracker(
     int64 parent_tracker_id,
     const std::string& file_id,
-    const SyncStatusCallback& callback) {
+    SyncStatusCode* status_out) {
   FileMetadata metadata;
   if (!index_->GetFileMetadata(file_id, &metadata)) {
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
+    *status_out = SYNC_STATUS_FAILED;
     return ACTIVATION_PENDING;
   }
   std::string title = metadata.details().title();
   DCHECK(!HasInvalidTitle(title));
 
   TrackerIDSet same_file_id_trackers =
       index_->GetFileTrackerIDsByFileID(file_id);
   scoped_ptr<FileTracker> tracker_to_be_activated(new FileTracker);
   FilterFileTrackersByParentAndTitle(
       index_.get(), same_file_id_trackers, parent_tracker_id,
@@ skipping 33 matching lines @@
   tracker_to_be_activated->set_active(true);
   *tracker_to_be_activated->mutable_synced_details() = metadata.details();
   if (tracker_to_be_activated->synced_details().file_kind() ==
       FILE_KIND_FOLDER) {
     tracker_to_be_activated->set_needs_folder_listing(true);
   }
   tracker_to_be_activated->set_dirty(false);
 
   index_->StoreFileTracker(tracker_to_be_activated.Pass());
 
-  WriteToDatabase(callback);
+  *status_out = WriteToDatabase();
   return ACTIVATION_PENDING;
 }
 
 void MetadataDatabase::DemoteTracker(int64 tracker_id) {
   index_->DemoteDirtyTracker(tracker_id);
-  WriteToDatabase(base::Bind(&EmptyStatusCallback));
+  WriteToDatabase();
 }
 
 bool MetadataDatabase::PromoteDemotedTrackers() {
   bool promoted = index_->PromoteDemotedDirtyTrackers();
-  WriteToDatabase(base::Bind(&EmptyStatusCallback));
+  WriteToDatabase();
   return promoted;
 }
 
 void MetadataDatabase::PromoteDemotedTracker(int64 tracker_id) {
   index_->PromoteDemotedDirtyTracker(tracker_id);
-  WriteToDatabase(base::Bind(&EmptyStatusCallback));
+  WriteToDatabase();
 }
 
 bool MetadataDatabase::GetDirtyTracker(
     FileTracker* tracker_out) const {
   int64 dirty_tracker_id = index_->PickDirtyTracker();
   if (!dirty_tracker_id)
     return false;
 
   if (tracker_out) {
     if (!index_->GetFileTracker(dirty_tracker_id, tracker_out)) {
@@ skipping 60 matching lines @@
 
   std::swap(*trackers_out, trackers);
   return true;
 }
 
 void MetadataDatabase::GetRegisteredAppIDs(std::vector<std::string>* app_ids) {
   DCHECK(app_ids);
   *app_ids = index_->GetRegisteredAppIDs();
 }
 
-void MetadataDatabase::SweepDirtyTrackers(
-    const std::vector<std::string>& file_ids,
-    const SyncStatusCallback& callback) {
+SyncStatusCode MetadataDatabase::SweepDirtyTrackers(
+    const std::vector<std::string>& file_ids) {
   std::set<int64> tracker_ids;
   for (size_t i = 0; i < file_ids.size(); ++i) {
     TrackerIDSet trackers_for_file_id =
         index_->GetFileTrackerIDsByFileID(file_ids[i]);
     for (TrackerIDSet::iterator itr = trackers_for_file_id.begin();
          itr != trackers_for_file_id.end(); ++itr)
       tracker_ids.insert(*itr);
   }
 
   for (std::set<int64>::iterator itr = tracker_ids.begin();
        itr != tracker_ids.end(); ++itr) {
     scoped_ptr<FileTracker> tracker(new FileTracker);
     if (!index_->GetFileTracker(*itr, tracker.get()) ||
         !CanClearDirty(*tracker))
       continue;
     tracker->set_dirty(false);
     index_->StoreFileTracker(tracker.Pass());
   }
 
-  WriteToDatabase(callback);
+  return WriteToDatabase();
 }
 
 MetadataDatabase::MetadataDatabase(
     const base::FilePath& database_path,
     bool enable_on_disk_index,
     leveldb::Env* env_override)
     : database_path_(database_path),
       env_override_(env_override),
       enable_on_disk_index_(enable_on_disk_index),
       largest_known_change_id_(0),
@@ skipping 252 matching lines @@
 
   TrackerIDSet trackers = index_->GetFileTrackerIDsByFileID(file_id);
   if (!trackers.empty()) {
     index_->StoreFileMetadata(metadata.Pass());
 
     if (option != UPDATE_TRACKER_FOR_SYNCED_FILE)
       MarkTrackerSetDirty(trackers, index_.get());
   }
 }
 
-void MetadataDatabase::WriteToDatabase(const SyncStatusCallback& callback) {
-  leveldb::Status status = db_->Commit();
-  callback.Run(LevelDBStatusToSyncStatusCode(status));
+
+SyncStatusCode MetadataDatabase::WriteToDatabase() {
+  return LevelDBStatusToSyncStatusCode(db_->Commit());
 }
 
 scoped_ptr<base::ListValue> MetadataDatabase::DumpFiles(
     const std::string& app_id) {
   scoped_ptr<base::ListValue> files(new base::ListValue);
 
   FileTracker app_root_tracker;
   if (!FindAppRootTracker(app_id, &app_root_tracker))
     return files.Pass();
 
@@ skipping 212 matching lines @@
       return false;
 
   if (!parents.empty())
     return false;
 
   return true;
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system