[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/extensions/api/file_system/file_system_api.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/extensions/api/file_system/file_system_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 456 matching lines @@
 }
 
 #endif
 
 }  // namespace file_system_api
 
 #if defined(OS_CHROMEOS)
 using file_system_api::ConsentProvider;
 #endif
 
-bool FileSystemGetDisplayPathFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemGetDisplayPathFunction::Run() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   base::FilePath file_path;
+  std::string error;
   if (!app_file_handler_util::ValidateFileEntryAndGetPath(
           filesystem_name, filesystem_path,
-          render_frame_host()->GetProcess()->GetID(), &file_path, &error_))
-    return false;
+          render_frame_host()->GetProcess()->GetID(), &file_path, &error)) {
+    return RespondNow(Error(error));
+  }
 
   file_path = path_util::PrettifyPath(file_path);
-  SetResult(base::MakeUnique<base::StringValue>(file_path.value()));
-  return true;
+  return RespondNow(
+      OneArgument(base::MakeUnique<base::StringValue>(file_path.value())));
 }
 
 FileSystemEntryFunction::FileSystemEntryFunction()
     : multiple_(false), is_directory_(false) {}
 
 void FileSystemEntryFunction::PrepareFilesForWritableApp(
     const std::vector<base::FilePath>& paths) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // TODO(cmihail): Path directory set should be initialized only with the
   // paths that are actually directories, but for now we will consider
@@ skipping 102 matching lines @@
   PrepareFilesForWritableApp(paths);
 }
 
 void FileSystemGetWritableEntryFunction::SetIsDirectoryOnFileThread() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   if (base::DirectoryExists(path_)) {
     is_directory_ = true;
   }
 }
 
-bool FileSystemIsWritableEntryFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemIsWritableEntryFunction::Run() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   std::string filesystem_id;
-  if (!storage::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id)) {
-    error_ = app_file_handler_util::kInvalidParameters;
-    return false;
-  }
+  if (!storage::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id))
+    return RespondNow(Error(app_file_handler_util::kInvalidParameters));
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   int renderer_id = render_frame_host()->GetProcess()->GetID();
   bool is_writable = policy->CanReadWriteFileSystem(renderer_id,
                                                     filesystem_id);
 
-  SetResult(base::MakeUnique<base::FundamentalValue>(is_writable));
-  return true;
+  return RespondNow(
+      OneArgument(base::MakeUnique<base::FundamentalValue>(is_writable)));
 }
 
 // Handles showing a dialog to the user to ask for the filename for a file to
 // save or open.
 class FileSystemChooseEntryFunction::FilePicker
     : public ui::SelectFileDialog::Listener {
  public:
   FilePicker(FileSystemChooseEntryFunction* function,
              content::WebContents* web_contents,
              const base::FilePath& suggested_name,
@@ skipping 541 matching lines @@
     return;
   }
 
   SavedFilesService* saved_files_service = SavedFilesService::Get(GetProfile());
   saved_files_service->RegisterFileEntry(
       extension_->id(), entry_id, path, file_info->is_directory);
   saved_files_service->EnqueueFileEntry(extension_->id(), entry_id);
   SendResponse(true);
 }
 
-bool FileSystemIsRestorableFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemIsRestorableFunction::Run() {
   std::string entry_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
-  SetResult(base::MakeUnique<base::FundamentalValue>(
-      SavedFilesService::Get(GetProfile())
-          ->IsRegistered(extension_->id(), entry_id)));
-  return true;
+  return RespondNow(OneArgument(base::MakeUnique<base::FundamentalValue>(
+      SavedFilesService::Get(Profile::FromBrowserContext(browser_context()))
+          ->IsRegistered(extension_->id(), entry_id))));
 }
 
 bool FileSystemRestoreEntryFunction::RunAsync() {
   std::string entry_id;
   bool needs_new_entry;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &needs_new_entry));
   const SavedFileEntry* file_entry = SavedFilesService::Get(
       GetProfile())->GetFileEntry(extension_->id(), entry_id);
   if (!file_entry) {
@@ skipping 10 matching lines @@
   if (needs_new_entry) {
     is_directory_ = file_entry->is_directory;
     std::unique_ptr<base::DictionaryValue> result = CreateResult();
     AddEntryToResult(file_entry->path, file_entry->id, result.get());
     SetResult(std::move(result));
   }
   SendResponse(true);
   return true;
 }
 
-bool FileSystemObserveDirectoryFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemObserveDirectoryFunction::Run() {
   NOTIMPLEMENTED();
-  error_ = kUnknownIdError;
-  return false;
+  return RespondNow(Error(kUnknownIdError));
 }
 
-bool FileSystemUnobserveEntryFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemUnobserveEntryFunction::Run() {
   NOTIMPLEMENTED();
-  error_ = kUnknownIdError;
-  return false;
+  return RespondNow(Error(kUnknownIdError));
 }
 
-bool FileSystemGetObservedEntriesFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemGetObservedEntriesFunction::Run() {
   NOTIMPLEMENTED();
-  error_ = kUnknownIdError;
-  return false;
+  return RespondNow(Error(kUnknownIdError));
 }
 
 #if !defined(OS_CHROMEOS)
 ExtensionFunction::ResponseAction FileSystemRequestFileSystemFunction::Run() {
   using api::file_system::RequestFileSystem::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   NOTIMPLEMENTED();
   return RespondNow(Error(kNotSupportedOnCurrentPlatformError));
@@ skipping 188 matching lines @@
     return RespondNow(Error(kNotSupportedOnNonKioskSessionError));
   std::vector<api::file_system::Volume> result_volume_list;
   FillVolumeList(chrome_details_.GetProfile(), &result_volume_list);
 
   return RespondNow(ArgumentList(
       api::file_system::GetVolumeList::Results::Create(result_volume_list)));
 }
 #endif
 
 }  // namespace extensions