[SyncFS] Make GetOriginStatusMap asynchronous

chrome/browser/sync_file_system/sync_file_system_service.cc

 // Copyright (c) 2012 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/sync_file_system_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 287 matching lines @@
       base::Bind(&SyncFileSystemService::DidInitializeFileSystem,
                  AsWeakPtr(), app_origin, callback));
 }
 
 SyncServiceState SyncFileSystemService::GetSyncServiceState() {
   // For now we always query the state from the main RemoteFileSyncService.
   return RemoteStateToSyncServiceState(remote_service_->GetCurrentState());
 }
 
 void SyncFileSystemService::GetExtensionStatusMap(
-    std::map<GURL, std::string>* status_map) {
-  DCHECK(status_map);
-  status_map->clear();
-  remote_service_->GetOriginStatusMap(status_map);
-  if (v2_remote_service_)
-    v2_remote_service_->GetOriginStatusMap(status_map);
+    const ExtensionStatusMapCallback& callback) {
+  remote_service_->GetOriginStatusMap(
+      base::Bind(&SyncFileSystemService::DidGetExtensionStatusMap,
+                 AsWeakPtr(), callback));
 }
 
 void SyncFileSystemService::DumpFiles(const GURL& origin,
                                       const DumpFilesCallback& callback) {
   DCHECK(!origin.is_empty());
 
   content::StoragePartition* storage_partition =
       content::BrowserContext::GetStoragePartitionForSite(profile_, origin);
   fileapi::FileSystemContext* file_system_context =
       storage_partition->GetFileSystemContext();
@@ skipping 225 matching lines @@
          itr != v2list->end();) {
       scoped_ptr<base::Value> item;
       itr = v2list->Erase(itr, &item);
       v1list->Append(item.release());
     }
   }
 
   callback.Run(*v1list);
 }
 
+void SyncFileSystemService::DidGetExtensionStatusMap(
+    const ExtensionStatusMapCallback& callback,
+    scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map) {
+  if (!v2_remote_service_) {
+    callback.Run(*status_map);
+    return;
+  }
+
+  v2_remote_service_->GetOriginStatusMap(
+      base::Bind(&SyncFileSystemService::DidGetV2ExtensionStatusMap,
+                 AsWeakPtr(),
+                 callback,
+                 base::Passed(&status_map)));
+}
+
+void SyncFileSystemService::DidGetV2ExtensionStatusMap(
+    const ExtensionStatusMapCallback& callback,
+    scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map_v1,
+    scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map_v2) {
+  // Merge |status_map_v2| into |status_map_v1|.
+  status_map_v1->insert(status_map_v2->begin(), status_map_v2->end());
+
+  callback.Run(*status_map_v1);
+}
+
 void SyncFileSystemService::SetSyncEnabledForTesting(bool enabled) {
   sync_enabled_ = enabled;
   remote_service_->SetSyncEnabled(sync_enabled_);
   if (v2_remote_service_)
     v2_remote_service_->SetSyncEnabled(sync_enabled_);
 }
 
 void SyncFileSystemService::DidGetLocalChangeStatus(
     const SyncFileStatusCallback& callback,
     SyncStatusCode status,
@@ skipping 212 matching lines @@
     v2_remote_service_->AddServiceObserver(v2_remote_syncer.get());
     v2_remote_service_->AddFileStatusObserver(this);
     v2_remote_service_->SetRemoteChangeProcessor(local_service_.get());
     v2_remote_service_->SetSyncEnabled(sync_enabled_);
     remote_sync_runners_.push_back(v2_remote_syncer.release());
   }
   return v2_remote_service_.get();
 }
 
 }  // namespace sync_file_system