[SyncFS] Make routines using metadata database async

chrome/browser/sync_file_system/drive_backend/sync_engine.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.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 373 matching lines @@
 
 void SyncEngine::SetSyncEnabled(bool enabled) {
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorker::SetSyncEnabled,
                  base::Unretained(sync_worker_.get()),
                  enabled));
 }
 
 void SyncEngine::PromoteDemotedChanges() {
-  MetadataDatabase* metadata_db = GetMetadataDatabase();
-  if (metadata_db && metadata_db->HasLowPriorityDirtyTracker()) {
-    metadata_db->PromoteLowerPriorityTrackersToNormal();
-    FOR_EACH_OBSERVER(
-        Observer,
-        service_observers_,
-        OnRemoteChangeQueueUpdated(metadata_db->CountDirtyTracker()));
-  }
+  worker_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncWorker::PromoteDemotedChanges,
+                 base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::ApplyLocalChange(
     const FileChange& local_change,
     const base::FilePath& local_path,
     const SyncFileMetadata& local_metadata,
     const fileapi::FileSystemURL& url,
     const SyncStatusCallback& callback) {
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorker::ApplyLocalChange,
                  base::Unretained(sync_worker_.get()),
                  local_change,
                  local_path,
                  local_metadata,
                  url,
                  RelayCallbackToCurrentThread(
                      FROM_HERE, callback)));
 }
 
-SyncTaskManager* SyncEngine::GetSyncTaskManagerForTesting() {
-  return sync_worker_->GetSyncTaskManager();
-}
-
 void SyncEngine::OnNotificationReceived() {
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SyncWorker::OnNotificationReceived,
                  base::Unretained(sync_worker_.get())));
 }
 
 void SyncEngine::OnPushNotificationEnabled(bool) {}
 
 void SyncEngine::OnReadyToSendRequests() {
@@ skipping 24 matching lines @@
 }
 
 drive::DriveServiceInterface* SyncEngine::GetDriveService() {
   return drive_service_.get();
 }
 
 drive::DriveUploaderInterface* SyncEngine::GetDriveUploader() {
   return drive_uploader_.get();
 }
 
-MetadataDatabase* SyncEngine::GetMetadataDatabase() {
-  // TODO(peria): Post task
-  return sync_worker_->GetMetadataDatabase();
-}
-
 SyncEngine::SyncEngine(
     scoped_ptr<drive::DriveServiceInterface> drive_service,
     scoped_ptr<drive::DriveUploaderInterface> drive_uploader,
     base::SequencedTaskRunner* worker_task_runner,
     drive::DriveNotificationManager* notification_manager,
     ExtensionServiceInterface* extension_service,
     SigninManagerBase* signin_manager)
     : drive_service_(drive_service.Pass()),
       drive_service_wrapper_(new DriveServiceWrapper(drive_service_.get())),
       drive_uploader_(drive_uploader.Pass()),
@@ skipping 24 matching lines @@
 
 void SyncEngine::UpdateServiceState(RemoteServiceState state,
                                     const std::string& description) {
   service_state_ = state;
 
   FOR_EACH_OBSERVER(
       Observer, service_observers_,
       OnRemoteServiceStateUpdated(state, description));
 }
 
-void SyncEngine::UpdateRegisteredApps() {
+void SyncEngine::UpdateRegisteredAppsForTesting() {
   if (!extension_service_)
     return;
 
-  MetadataDatabase* metadata_db = GetMetadataDatabase();
+  MetadataDatabase* metadata_db = sync_worker_->GetMetadataDatabase();
   DCHECK(metadata_db);
   std::vector<std::string> app_ids;
   metadata_db->GetRegisteredAppIDs(&app_ids);
 
   // Update the status of every origin using status from ExtensionService.
   for (std::vector<std::string>::const_iterator itr = app_ids.begin();
        itr != app_ids.end(); ++itr) {
     const std::string& app_id = *itr;
     GURL origin =
         extensions::Extension::GetBaseURLFromExtensionId(app_id);
@@ skipping 16 matching lines @@
         tracker.tracker_kind() == TRACKER_KIND_APP_ROOT;
     if (is_app_enabled && !is_app_root_tracker_enabled)
       EnableOrigin(origin, base::Bind(&EmptyStatusCallback));
     else if (!is_app_enabled && is_app_root_tracker_enabled)
       DisableOrigin(origin, base::Bind(&EmptyStatusCallback));
   }
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system