[SyncFS] Make DumpFiles async

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 114 matching lines @@
   DCHECK(num_results);
 
   if (file)
     file->SetString("status", SyncFileStatusToString(sync_file_status));
 
   // Once all results have been received, run the callback to signal end.
   DCHECK_LE(*num_results, files->GetSize());
   if (++*num_results < files->GetSize())
     return;
 
-  callback.Run(files);
+  callback.Run(*files);
 }
 
 // We need this indirection because WeakPtr can only be bound to methods
 // without a return value.
 LocalChangeProcessor* GetLocalChangeProcessorAdapter(
     base::WeakPtr<SyncFileSystemService> service,
     const GURL& origin) {
   if (!service)
     return NULL;
   return service->GetLocalChangeProcessor(origin);
@@ skipping 355 matching lines @@
   callback.Run(status);
 }
 
 void SyncFileSystemService::DidInitializeFileSystemForDump(
     const GURL& origin,
     const DumpFilesCallback& callback,
     SyncStatusCode status) {
   DCHECK(!origin.is_empty());
 
   if (status != SYNC_STATUS_OK) {
-    base::ListValue empty_result;
-    callback.Run(&empty_result);
+    callback.Run(base::ListValue());
     return;
   }
 
-  base::ListValue* files =
-      GetRemoteService(origin)->DumpFiles(origin).release();
-  if (!files) {
-    callback.Run(new base::ListValue);
+  GetRemoteService(origin)->DumpFiles(
+      origin,
+      base::Bind(
+          &SyncFileSystemService::DidDumpFiles,
+          AsWeakPtr(),
+          origin,
+          callback));
+}
+
+void SyncFileSystemService::DidDumpFiles(
+    const GURL& origin,
+    const DumpFilesCallback& callback,
+    scoped_ptr<base::ListValue> dump_files) {
+  if (!dump_files || !dump_files->GetSize()) {
+    callback.Run(base::ListValue());
     return;
   }
 
-  if (!files->GetSize()) {
-    callback.Run(files);
-    return;
-  }
-
-  base::Callback<void(base::DictionaryValue* file,
-                      SyncStatusCode sync_status,
-                      SyncFileStatus sync_file_status)> completion_callback =
-      base::Bind(&DidGetFileSyncStatusForDump, base::Owned(files),
-                 base::Owned(new size_t(0)), callback);
+  base::ListValue* files = dump_files.get();
+  base::Callback<void(base::DictionaryValue*,
+                      SyncStatusCode,
+                      SyncFileStatus)> completion_callback =
+      base::Bind(&DidGetFileSyncStatusForDump,
+                 base::Owned(dump_files.release()),
+                 base::Owned(new size_t(0)),
+                 callback);
 
   // After all metadata loaded, sync status can be added to each entry.
   for (size_t i = 0; i < files->GetSize(); ++i) {
     base::DictionaryValue* file = NULL;
     std::string path_string;
     if (!files->GetDictionary(i, &file) ||
         !file->GetString("path", &path_string)) {
       NOTREACHED();
       completion_callback.Run(
           NULL, SYNC_FILE_ERROR_FAILED, SYNC_FILE_STATUS_UNKNOWN);
@@ skipping 233 matching lines @@
     v2_remote_service_->SetRemoteChangeProcessor(local_service_.get());
     v2_remote_service_->SetSyncEnabled(sync_enabled_);
     v2_remote_service_->SetDefaultConflictResolutionPolicy(
         remote_service_->GetDefaultConflictResolutionPolicy());
     remote_sync_runners_.push_back(v2_remote_syncer.release());
   }
   return v2_remote_service_.get();
 }
 
 }  // namespace sync_file_system