gdata: Convert public synchronous functions in GDataFileSystem to asynchronous.

chrome/browser/chromeos/extensions/file_handler_util.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/chromeos/extensions/file_handler_util.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_writer.h"
@@ skipping 529 matching lines @@
           handler,
           handler_pid,
           action_id_,
           file_urls));
 }
 
 void FileTaskExecutor::ExecuteFailedOnUIThread() {
   Done(false);
 }
 
+const Extension* FileTaskExecutor::GetExtension() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  ExtensionService* service = profile_->GetExtensionService();
+  return service ? service->GetExtensionById(extension_id_, false) :
+                   NULL;
+}
+
 void FileTaskExecutor::ExecuteFileActionsOnUIThread(
     const std::string& file_system_name,
     const GURL& file_system_root,
     const FileDefinitionList& file_list,
     int handler_pid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  ExtensionService* service = profile_->GetExtensionService();
-  if (!service) {
-    Done(false);
-    return;
-  }
-
-  const Extension* extension = service->GetExtensionById(extension_id_, false);
+  const Extension* extension = GetExtension();
   if (!extension) {
     Done(false);
     return;
   }
 
-  InitHandlerHostFileAccessPermissions(file_list, extension, action_id_);
+  InitHandlerHostFileAccessPermissions(
+      file_list,
+      extension,
+      action_id_,
+      base::Bind(&FileTaskExecutor::OnInitAccessForExecuteFileActionsOnUIThread,
+                 this,
+                 file_system_name,
+                 file_system_root,
+                 file_list,
+                 handler_pid));
+}
+
+void FileTaskExecutor::OnInitAccessForExecuteFileActionsOnUIThread(
+    const std::string& file_system_name,
+    const GURL& file_system_root,
+    const FileDefinitionList& file_list,
+    int handler_pid) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  const Extension* extension = GetExtension();
+  if (!extension) {
+    Done(false);
+    return;
+  }
 
   if (handler_pid > 0) {
     SetupPermissionsAndDispatchEvent(file_system_name, file_system_root,
         file_list, handler_pid, NULL);
   } else {
     // We have to wake the handler background page before we proceed.
     extensions::LazyBackgroundTaskQueue* queue =
         ExtensionSystem::Get(profile_)->lazy_background_task_queue();
     if (!queue->ShouldEnqueueTask(profile_, extension)) {
       Done(false);
@@ skipping 62 matching lines @@
       extension_id_, std::string("fileBrowserHandler.onExecute"),
       json_args, profile_,
       GURL());
 
   Done(true);
 }
 
 void FileTaskExecutor::InitHandlerHostFileAccessPermissions(
     const FileDefinitionList& file_list,
     const Extension* handler_extension,
-    const std::string& action_id) {
+    const std::string& action_id,
+    const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  scoped_ptr<std::vector<FilePath> > gdata_paths(new std::vector<FilePath>);
   for (FileDefinitionList::const_iterator iter = file_list.begin();
        iter != file_list.end();
        ++iter) {
     // Setup permission for file's absolute file.
     handler_host_permissions_.push_back(std::make_pair(
         iter->absolute_path,
         GetAccessPermissionsForHandler(handler_extension, action_id)));
 
-    if (!gdata::util::IsUnderGDataMountPoint(iter->absolute_path))
-      continue;
+    if (gdata::util::IsUnderGDataMountPoint(iter->absolute_path))
+      gdata_paths->push_back(iter->virtual_path);
+  }
 
-    // If the file is on gdata mount point, we'll have to give handler host
-    // permissions for file's gdata cache paths.
-    // This has to be called on UI thread.
-    gdata::util::InsertGDataCachePathsPermissions(profile_, iter->virtual_path,
-        &handler_host_permissions_);
+  if (gdata_paths->empty()) {
+    // Invoke callback if none of the files are on gdata mount point.
+    callback.Run();
+    return;
   }
+
+  // For files on gdata mount point, we'll have to give handler host permissions
+  // for their cache paths. This has to be called on UI thread.
+  gdata::util::InsertGDataCachePathsPermissions(profile_,
+                                                gdata_paths.Pass(),
+                                                &handler_host_permissions_,
+                                                callback);
 }
 
 void FileTaskExecutor::SetupHandlerHostFileAccessPermissions(int handler_pid) {
   for (size_t i = 0; i < handler_host_permissions_.size(); i++) {
     content::ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
         handler_pid,
         handler_host_permissions_[i].first,
         handler_host_permissions_[i].second);
   }
 
   // We don't need this anymore.
   handler_host_permissions_.clear();
 }
 
 } // namespace file_handler_util