Drive extension functions from ExtensionFunction::Run. The

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 "apps/app_window.h"
 #include "apps/app_window_registry.h"
 #include "apps/browser/file_handler_util.h"
 #include "apps/saved_files_service.h"
@@ skipping 335 matching lines @@
 }
 
 void FileSystemEntryFunction::HandleWritableFileError(
     const base::FilePath& error_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   error_ = base::StringPrintf(kWritableFileErrorFormat,
                               error_path.BaseName().AsUTF8Unsafe().c_str());
   SendResponse(false);
 }
 
-bool FileSystemGetWritableEntryFunction::RunImpl() {
+bool FileSystemGetWritableEntryFunction::RunAsync() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   if (!app_file_handler_util::HasFileSystemWritePermission(extension_)) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
@@ skipping 459 matching lines @@
     *suggested_name = suggested_name->BaseName();
     if (suggested_name->IsAbsolute())
       *suggested_name = base::FilePath();
 
     *suggested_extension = suggested_name->Extension();
     if (!suggested_extension->empty())
       suggested_extension->erase(suggested_extension->begin());  // drop the .
   }
 }
 
-bool FileSystemChooseEntryFunction::RunImpl() {
+bool FileSystemChooseEntryFunction::RunAsync() {
   scoped_ptr<ChooseEntry::Params> params(ChooseEntry::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   base::FilePath suggested_name;
   ui::SelectFileDialog::FileTypeInfo file_type_info;
   ui::SelectFileDialog::Type picker_type =
       ui::SelectFileDialog::SELECT_OPEN_FILE;
 
   file_system::ChooseEntryOptions* options = params->options.get();
   if (options) {
@@ skipping 48 matching lines @@
                  this,
                  suggested_name,
                  previous_path),
       base::Bind(&FileSystemChooseEntryFunction::ShowPicker,
                  this,
                  file_type_info,
                  picker_type));
   return true;
 }
 
-bool FileSystemRetainEntryFunction::RunImpl() {
+bool FileSystemRetainEntryFunction::RunAsync() {
   std::string entry_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   SavedFilesService* saved_files_service = SavedFilesService::Get(GetProfile());
   // Add the file to the retain list if it is not already on there.
   if (!saved_files_service->IsRegistered(extension_->id(), entry_id)) {
     std::string filesystem_name;
     std::string filesystem_path;
     EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_name));
     EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &filesystem_path));
     if (!app_file_handler_util::ValidateFileEntryAndGetPath(filesystem_name,
@@ skipping 34 matching lines @@
 }
 
 bool FileSystemIsRestorableFunction::RunSync() {
   std::string entry_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   SetResult(new base::FundamentalValue(SavedFilesService::Get(
       GetProfile())->IsRegistered(extension_->id(), entry_id)));
   return true;
 }
 
-bool FileSystemRestoreEntryFunction::RunImpl() {
+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) {
     error_ = kUnknownIdError;
     return false;
   }
 
   SavedFilesService::Get(GetProfile())
       ->EnqueueFileEntry(extension_->id(), entry_id);
 
   // Only create a new file entry if the renderer requests one.
   // |needs_new_entry| will be false if the renderer already has an Entry for
   // |entry_id|.
   if (needs_new_entry) {
     is_directory_ = file_entry->is_directory;
     CreateResponse();
     AddEntryToResponse(file_entry->path, file_entry->id);
   }
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions