Drive extension functions from ExtensionFunction::Run. The

chrome/browser/extensions/api/management/management_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/management/management_api.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 358 matching lines @@
   std::string manifest_;
 
   // Results of parsing.
   scoped_ptr<base::DictionaryValue> parsed_manifest_;
 
   std::string error_;
 };
 
 }  // namespace
 
-bool ManagementGetPermissionWarningsByManifestFunction::RunImpl() {
+bool ManagementGetPermissionWarningsByManifestFunction::RunAsync() {
   scoped_ptr<management::GetPermissionWarningsByManifest::Params> params(
       management::GetPermissionWarningsByManifest::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   scoped_refptr<SafeManifestJSONParser> parser =
       new SafeManifestJSONParser(this, params->manifest_str);
   parser->Start();
 
   // Matched with a Release() in OnParseSuccess/Failure().
   AddRef();
@@ skipping 12 matching lines @@
   if (!extension.get()) {
     OnParseFailure(keys::kExtensionCreateError);
     return;
   }
 
   std::vector<std::string> warnings = CreateWarningsList(extension.get());
   results_ =
       management::GetPermissionWarningsByManifest::Results::Create(warnings);
   SendResponse(true);
 
-  // Matched with AddRef() in RunImpl().
+  // Matched with AddRef() in RunAsync().
   Release();
 }
 
 void ManagementGetPermissionWarningsByManifestFunction::OnParseFailure(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
 
-  // Matched with AddRef() in RunImpl().
+  // Matched with AddRef() in RunAsync().
   Release();
 }
 
 bool ManagementLaunchAppFunction::RunSync() {
   scoped_ptr<management::LaunchApp::Params> params(
       management::LaunchApp::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
     error_ = ErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
@@ skipping 21 matching lines @@
 
   return true;
 }
 
 ManagementSetEnabledFunction::ManagementSetEnabledFunction() {
 }
 
 ManagementSetEnabledFunction::~ManagementSetEnabledFunction() {
 }
 
-bool ManagementSetEnabledFunction::RunImpl() {
+bool ManagementSetEnabledFunction::RunAsync() {
   scoped_ptr<management::SetEnabled::Params> params(
       management::SetEnabled::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   extension_id_ = params->id;
 
   const Extension* extension = service()->GetInstalledExtension(extension_id_);
   if (!extension || extension->ShouldNotBeVisible()) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
@@ skipping 130 matching lines @@
   Finish(false);
   Release();
 }
 
 ManagementUninstallFunction::ManagementUninstallFunction() {
 }
 
 ManagementUninstallFunction::~ManagementUninstallFunction() {
 }
 
-bool ManagementUninstallFunction::RunImpl() {
+bool ManagementUninstallFunction::RunAsync() {
   scoped_ptr<management::Uninstall::Params> params(
       management::Uninstall::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(extension_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool show_confirm_dialog = true;
   // By default confirmation dialog isn't shown when uninstalling self, but this
   // can be overridden with showConfirmDialog.
   if (params->id == extension_->id()) {
     show_confirm_dialog = params->options.get() &&
                           params->options->show_confirm_dialog.get() &&
                           *params->options->show_confirm_dialog;
   }
   if (show_confirm_dialog && !user_gesture()) {
     error_ = keys::kGestureNeededForUninstallError;
     return false;
   }
   return Uninstall(params->id, show_confirm_dialog);
 }
 
 ManagementUninstallSelfFunction::ManagementUninstallSelfFunction() {
 }
 
 ManagementUninstallSelfFunction::~ManagementUninstallSelfFunction() {
 }
 
-bool ManagementUninstallSelfFunction::RunImpl() {
+bool ManagementUninstallSelfFunction::RunAsync() {
   scoped_ptr<management::UninstallSelf::Params> params(
       management::UninstallSelf::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool show_confirm_dialog = false;
   if (params->options.get() && params->options->show_confirm_dialog.get())
     show_confirm_dialog = *params->options->show_confirm_dialog;
   return Uninstall(extension_->id(), show_confirm_dialog);
 }
 
 ManagementCreateAppShortcutFunction::ManagementCreateAppShortcutFunction() {
 }
 
 ManagementCreateAppShortcutFunction::~ManagementCreateAppShortcutFunction() {
 }
 
 // static
 void ManagementCreateAppShortcutFunction::SetAutoConfirmForTest(
     bool should_proceed) {
   auto_confirm_for_test = should_proceed ? PROCEED : ABORT;
 }
 
 void ManagementCreateAppShortcutFunction::OnCloseShortcutPrompt(bool created) {
   if (!created)
     error_ = keys::kCreateShortcutCanceledError;
   SendResponse(created);
   Release();
 }
 
-bool ManagementCreateAppShortcutFunction::RunImpl() {
+bool ManagementCreateAppShortcutFunction::RunAsync() {
   if (!user_gesture()) {
     error_ = keys::kGestureNeededForCreateAppShortcutError;
     return false;
   }
 
   scoped_ptr<management::CreateAppShortcut::Params> params(
       management::CreateAppShortcut::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
@@ skipping 132 matching lines @@
   return g_factory.Pointer();
 }
 
 void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
   management_event_router_.reset(
       new ManagementEventRouter(Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions