Drive extension functions from ExtensionFunction::Run. The

chrome/browser/extensions/api/developer_private/developer_private_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/developer_private/developer_private_api.h"
 
 #include "apps/app_load_service.h"
 #include "apps/app_restore_service.h"
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
@@ skipping 577 matching lines @@
         -1,
         -1,
         false,
         BackgroundInfo::HasGeneratedBackgroundPage(extension)));
     }
   }
 
   return result;
 }
 
-bool DeveloperPrivateGetItemsInfoFunction::RunImpl() {
+bool DeveloperPrivateGetItemsInfoFunction::RunAsync() {
   scoped_ptr<developer::GetItemsInfo::Params> params(
       developer::GetItemsInfo::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool include_disabled = params->include_disabled;
   bool include_terminated = params->include_terminated;
 
   extensions::ExtensionSet items;
 
   ExtensionRegistry* registry = ExtensionRegistry::Get(GetProfile());
@@ skipping 273 matching lines @@
     // This can happen if the host has gone away since the page was displayed.
     return false;
   }
 
   DevToolsWindow::OpenDevToolsWindow(host);
   return true;
 }
 
 DeveloperPrivateInspectFunction::~DeveloperPrivateInspectFunction() {}
 
-bool DeveloperPrivateLoadUnpackedFunction::RunImpl() {
+bool DeveloperPrivateLoadUnpackedFunction::RunAsync() {
   base::string16 select_title =
       l10n_util::GetStringUTF16(IDS_EXTENSION_LOAD_FROM_DIRECTORY);
 
   // Balanced in FileSelected / FileSelectionCanceled.
   AddRef();
   bool result = ShowPicker(
       ui::SelectFileDialog::SELECT_FOLDER,
       DeveloperPrivateAPI::Get(GetProfile())->GetLastUnpackedDirectory(),
       select_title,
       ui::SelectFileDialog::FileTypeInfo(),
@@ skipping 36 matching lines @@
   new EntryPicker(this,
                   app_window->web_contents(),
                   picker_type,
                   last_directory,
                   select_title,
                   info,
                   file_type_index);
   return true;
 }
 
-bool DeveloperPrivateChooseEntryFunction::RunImpl() { return false; }
+bool DeveloperPrivateChooseEntryFunction::RunAsync() {
+  return false;
+}
 
 DeveloperPrivateChooseEntryFunction::~DeveloperPrivateChooseEntryFunction() {}
 
 void DeveloperPrivatePackDirectoryFunction::OnPackSuccess(
     const base::FilePath& crx_file,
     const base::FilePath& pem_file) {
   developer::PackDirectoryResponse response;
   response.message = base::UTF16ToUTF8(
       PackExtensionJob::StandardSuccessMessage(crx_file, pem_file));
   response.status = developer::PACK_STATUS_SUCCESS;
@@ skipping 13 matching lines @@
     response.override_flags = ExtensionCreator::kOverwriteCRX;
     response.status = developer::PACK_STATUS_WARNING;
   } else {
     response.status = developer::PACK_STATUS_ERROR;
   }
   results_ = developer::PackDirectory::Results::Create(response);
   SendResponse(true);
   Release();
 }
 
-bool DeveloperPrivatePackDirectoryFunction::RunImpl() {
+bool DeveloperPrivatePackDirectoryFunction::RunAsync() {
   scoped_ptr<PackDirectory::Params> params(
       PackDirectory::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   int flags = params->flags;
   item_path_str_ = params->path;
   key_path_str_ = params->private_key_path;
 
   base::FilePath root_directory =
       base::FilePath::FromUTF8Unsafe(item_path_str_);
@@ skipping 33 matching lines @@
 }
 
 DeveloperPrivatePackDirectoryFunction::DeveloperPrivatePackDirectoryFunction()
 {}
 
 DeveloperPrivatePackDirectoryFunction::~DeveloperPrivatePackDirectoryFunction()
 {}
 
 DeveloperPrivateLoadUnpackedFunction::~DeveloperPrivateLoadUnpackedFunction() {}
 
-bool DeveloperPrivateLoadDirectoryFunction::RunImpl() {
+bool DeveloperPrivateLoadDirectoryFunction::RunAsync() {
   // TODO(grv) : add unittests.
   std::string directory_url_str;
   std::string filesystem_name;
   std::string filesystem_path;
 
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &directory_url_str));
 
   // Directory url is non empty only for syncfilesystem.
@@ skipping 186 matching lines @@
                    this));
   }
 }
 
 DeveloperPrivateLoadDirectoryFunction::DeveloperPrivateLoadDirectoryFunction()
     : pending_copy_operations_count_(0), success_(true) {}
 
 DeveloperPrivateLoadDirectoryFunction::~DeveloperPrivateLoadDirectoryFunction()
     {}
 
-bool DeveloperPrivateChoosePathFunction::RunImpl() {
+bool DeveloperPrivateChoosePathFunction::RunAsync() {
   scoped_ptr<developer::ChoosePath::Params> params(
       developer::ChoosePath::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   ui::SelectFileDialog::Type type = ui::SelectFileDialog::SELECT_FOLDER;
   ui::SelectFileDialog::FileTypeInfo info;
   if (params->select_type == developer::SELECT_TYPE_FILE) {
     type = ui::SelectFileDialog::SELECT_OPEN_FILE;
   }
   base::string16 select_title;
@@ skipping 48 matching lines @@
 DeveloperPrivateIsProfileManagedFunction::
     ~DeveloperPrivateIsProfileManagedFunction() {
 }
 
 DeveloperPrivateRequestFileSourceFunction::
     DeveloperPrivateRequestFileSourceFunction() {}
 
 DeveloperPrivateRequestFileSourceFunction::
     ~DeveloperPrivateRequestFileSourceFunction() {}
 
-bool DeveloperPrivateRequestFileSourceFunction::RunImpl() {
+bool DeveloperPrivateRequestFileSourceFunction::RunAsync() {
   scoped_ptr<developer::RequestFileSource::Params> params(
       developer::RequestFileSource::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   base::DictionaryValue* dict = NULL;
   if (!params->dict->GetAsDictionary(&dict)) {
     NOTREACHED();
     return false;
   }
 
   AddRef();  // Balanced in LaunchCallback().
   error_ui_util::HandleRequestFileSource(
       dict,
       GetProfile(),
       base::Bind(&DeveloperPrivateRequestFileSourceFunction::LaunchCallback,
                  base::Unretained(this)));
   return true;
 }
 
 void DeveloperPrivateRequestFileSourceFunction::LaunchCallback(
     const base::DictionaryValue& results) {
   SetResult(results.DeepCopy());
   SendResponse(true);
-  Release();  // Balanced in RunImpl().
+  Release();  // Balanced in RunAsync().
 }
 
 DeveloperPrivateOpenDevToolsFunction::DeveloperPrivateOpenDevToolsFunction() {}
 DeveloperPrivateOpenDevToolsFunction::~DeveloperPrivateOpenDevToolsFunction() {}
 
-bool DeveloperPrivateOpenDevToolsFunction::RunImpl() {
+bool DeveloperPrivateOpenDevToolsFunction::RunAsync() {
   scoped_ptr<developer::OpenDevTools::Params> params(
       developer::OpenDevTools::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   base::DictionaryValue* dict = NULL;
   if (!params->dict->GetAsDictionary(&dict)) {
     NOTREACHED();
     return false;
   }
 
   error_ui_util::HandleOpenDevTools(dict);
 
   return true;
 }
 
 }  // namespace api
 
 }  // namespace extensions