[Extensions] Consolidate ExtensionFunction::SendResponse()s

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 1312 matching lines @@
 
 void FileSystemRequestFileSystemFunction::OnConsentReceived(
     const base::WeakPtr<file_manager::Volume>& volume,
     bool writable,
     ConsentProvider::Consent result) {
   using file_manager::VolumeManager;
   using file_manager::Volume;
 
   switch (result) {
     case ConsentProvider::CONSENT_REJECTED:
-      SetError(kSecurityError);
-      SendResponse(false);
+      Respond(Error(kSecurityError));
       return;
 
     case ConsentProvider::CONSENT_IMPOSSIBLE:
-      SetError(kConsentImpossible);
-      SendResponse(false);
+      Respond(Error(kConsentImpossible));
       return;
 
     case ConsentProvider::CONSENT_GRANTED:
       break;
   }
 
   if (!volume.get()) {
-    SetError(kVolumeNotFoundError);
-    SendResponse(false);
+    Respond(Error(kVolumeNotFoundError));
     return;
   }
 
   const GURL site =
       util::GetSiteForExtensionId(extension_id(), chrome_details_.GetProfile());
   scoped_refptr<storage::FileSystemContext> file_system_context =
       content::BrowserContext::GetStoragePartitionForSite(
           chrome_details_.GetProfile(), site)->GetFileSystemContext();
   storage::ExternalFileSystemBackend* const backend =
       file_system_context->external_backend();
   DCHECK(backend);
 
   base::FilePath virtual_path;
   if (!backend->GetVirtualPath(volume->mount_path(), &virtual_path)) {
-    SetError(kSecurityError);
-    SendResponse(false);
+    Respond(Error(kSecurityError));
     return;
   }
 
   storage::IsolatedContext* const isolated_context =
       storage::IsolatedContext::GetInstance();
   DCHECK(isolated_context);
 
   const storage::FileSystemURL original_url =
       file_system_context->CreateCrackedFileSystemURL(
           GURL(std::string(kExtensionScheme) + url::kStandardSchemeSeparator +
                extension_id()),
           storage::kFileSystemTypeExternal, virtual_path);
 
   // Set a fixed register name, as the automatic one would leak the mount point
   // directory.
   std::string register_name = "fs";
   const std::string file_system_id =
       isolated_context->RegisterFileSystemForPath(
           storage::kFileSystemTypeNativeForPlatformApp,
           std::string() /* file_system_id */, original_url.path(),
           &register_name);
   if (file_system_id.empty()) {
-    SetError(kSecurityError);
-    SendResponse(false);
+    Respond(Error(kSecurityError));
     return;
   }
 
   backend->GrantFileAccessToExtension(extension_->id(), virtual_path);
 
   // Grant file permissions to the renderer hosting component.
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   DCHECK(policy);
 
@@ skipping 14 matching lines @@
     policy->GrantDeleteFromFileSystem(
         render_frame_host()->GetProcess()->GetID(), file_system_id);
     policy->GrantCreateFileForFileSystem(
         render_frame_host()->GetProcess()->GetID(), file_system_id);
   }
 
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("file_system_id", file_system_id);
   dict->SetString("file_system_path", register_name);
 
-  SetResult(std::move(dict));
-  SendResponse(true);
+  Respond(OneArgument(std::move(dict)));
 }
 
 FileSystemGetVolumeListFunction::FileSystemGetVolumeListFunction()
     : chrome_details_(this) {
 }
 
 FileSystemGetVolumeListFunction::~FileSystemGetVolumeListFunction() {
 }
 
 ExtensionFunction::ResponseAction FileSystemGetVolumeListFunction::Run() {
   // Only kiosk apps in kiosk sessions can use this API.
   // Additionally it is enabled for whitelisted component extensions and apps.
   file_system_api::ConsentProviderDelegate consent_provider_delegate(
       chrome_details_.GetProfile(), render_frame_host());
   file_system_api::ConsentProvider consent_provider(&consent_provider_delegate);
 
   if (!consent_provider.IsGrantable(*extension()))
     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