[Extensions] Convert some ChromeSyncExtensionFunctions

chrome/browser/chromeos/extensions/file_system_provider/file_system_provider_api.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/chromeos/extensions/file_system_provider/file_system_provider_api.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 96 matching lines @@
         opened_file_item.mode =
             extensions::api::file_system_provider::OPEN_FILE_MODE_WRITE;
         break;
     }
     output->opened_files.push_back(std::move(opened_file_item));
   }
 }
 
 }  // namespace
 
-bool FileSystemProviderMountFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemProviderMountFunction::Run() {
   using api::file_system_provider::Mount::Params;
   const std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // It's an error if the file system Id is empty.
   if (params->options.file_system_id.empty()) {
-    SetError(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION));
-    return false;
+    return RespondNow(
+        Error(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION)));
   }
 
   // It's an error if the display name is empty.
   if (params->options.display_name.empty()) {
-    SetError(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION));
-    return false;
+    return RespondNow(
+        Error(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION)));
   }
 
   // If the opened files limit is set, then it must be larger or equal than 0.
   if (params->options.opened_files_limit.get() &&
       *params->options.opened_files_limit.get() < 0) {
-    SetError(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION));
-    return false;
+    return RespondNow(
+        Error(FileErrorToString(base::File::FILE_ERROR_INVALID_OPERATION)));
   }
 
-  Service* const service = Service::Get(GetProfile());
+  Service* const service =
+      Service::Get(Profile::FromBrowserContext(browser_context()));
   DCHECK(service);
 
   MountOptions options;
   options.file_system_id = params->options.file_system_id;
   options.display_name = params->options.display_name;
   options.writable = params->options.writable != nullptr;
   options.opened_files_limit = params->options.opened_files_limit.get()
                                    ? *params->options.opened_files_limit.get()
                                    : 0;
   options.supports_notify_tag = params->options.supports_notify_tag != nullptr;
 
   const base::File::Error result =
       service->MountFileSystem(extension_id(), options);
-  if (result != base::File::FILE_OK) {
-    SetError(FileErrorToString(result));
-    return false;
-  }
+  if (result != base::File::FILE_OK)
+    return RespondNow(Error(FileErrorToString(result)));
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool FileSystemProviderUnmountFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemProviderUnmountFunction::Run() {
   using api::file_system_provider::Unmount::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
-  Service* const service = Service::Get(GetProfile());
+  Service* const service =
+      Service::Get(Profile::FromBrowserContext(browser_context()));
   DCHECK(service);
 
   const base::File::Error result =
       service->UnmountFileSystem(extension_id(), params->options.file_system_id,
                                  Service::UNMOUNT_REASON_USER);
-  if (result != base::File::FILE_OK) {
-    SetError(FileErrorToString(result));
-    return false;
-  }
+  if (result != base::File::FILE_OK)
+    return RespondNow(Error(FileErrorToString(result)));
 
-  return true;
+  return RespondNow(NoArguments());
 }
 
-bool FileSystemProviderGetAllFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemProviderGetAllFunction::Run() {
   using api::file_system_provider::FileSystemInfo;
-  Service* const service = Service::Get(GetProfile());
+  Service* const service =
+      Service::Get(Profile::FromBrowserContext(browser_context()));
   DCHECK(service);
 
   const std::vector<ProvidedFileSystemInfo> file_systems =
       service->GetProvidedFileSystemInfoList();
   std::vector<FileSystemInfo> items;
 
   for (const auto& file_system_info : file_systems) {
     if (file_system_info.extension_id() == extension_id()) {
       FileSystemInfo item;
 
       chromeos::file_system_provider::ProvidedFileSystemInterface* const
           file_system =
               service->GetProvidedFileSystem(file_system_info.extension_id(),
                                              file_system_info.file_system_id());
       DCHECK(file_system);
 
       FillFileSystemInfo(file_system_info, *file_system->GetWatchers(),
                          file_system->GetOpenedFiles(), &item);
       items.push_back(std::move(item));
     }
   }
 
-  SetResultList(api::file_system_provider::GetAll::Results::Create(items));
-  return true;
+  return RespondNow(
+      ArgumentList(api::file_system_provider::GetAll::Results::Create(items)));
 }
 
-bool FileSystemProviderGetFunction::RunSync() {
+ExtensionFunction::ResponseAction FileSystemProviderGetFunction::Run() {
   using api::file_system_provider::Get::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   using api::file_system_provider::FileSystemInfo;
-  Service* const service = Service::Get(GetProfile());
+  Service* const service =
+      Service::Get(Profile::FromBrowserContext(browser_context()));
   DCHECK(service);
 
   chromeos::file_system_provider::ProvidedFileSystemInterface* const
       file_system = service->GetProvidedFileSystem(extension_id(),
                                                    params->file_system_id);
 
   if (!file_system) {
-    SetError(FileErrorToString(base::File::FILE_ERROR_NOT_FOUND));
-    return false;
+    return RespondNow(
+        Error(FileErrorToString(base::File::FILE_ERROR_NOT_FOUND)));
   }
 
   FileSystemInfo file_system_info;
   FillFileSystemInfo(file_system->GetFileSystemInfo(),
                      *file_system->GetWatchers(), file_system->GetOpenedFiles(),
                      &file_system_info);
-  SetResultList(
-      api::file_system_provider::Get::Results::Create(file_system_info));
-  return true;
+  return RespondNow(ArgumentList(
+      api::file_system_provider::Get::Results::Create(file_system_info)));
 }
 
 bool FileSystemProviderNotifyFunction::RunAsync() {
   using api::file_system_provider::Notify::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   Service* const service = Service::Get(GetProfile());
   DCHECK(service);
 
@@ skipping 101 matching lines @@
   using api::file_system_provider_internal::OperationRequestedError::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::File::Error error = ProviderErrorToFileError(params->error);
   return RejectRequest(RequestValue::CreateForOperationError(std::move(params)),
                        error);
 }
 
 }  // namespace extensions