Revert 176015

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 201 matching lines @@
 } // namespace
 
 ExtensionService* ManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
 ExtensionService* AsyncManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
-bool ManagementGetAllFunction::RunImpl() {
+bool GetAllExtensionsFunction::RunImpl() {
   ExtensionInfoList extensions;
   ExtensionSystem* system = ExtensionSystem::Get(profile());
 
   AddExtensionInfo(*service()->extensions(), system, &extensions);
   AddExtensionInfo(*service()->disabled_extensions(), system, &extensions);
   AddExtensionInfo(*service()->terminated_extensions(), system, &extensions);
 
   results_ = management::GetAll::Results::Create(extensions);
   return true;
 }
 
-bool ManagementGetFunction::RunImpl() {
+bool GetExtensionByIdFunction::RunImpl() {
   scoped_ptr<management::Get::Params> params(
       management::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
     error_ = ErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
                                                      params->id);
     return false;
   }
 
   scoped_ptr<management::ExtensionInfo> info = CreateExtensionInfo(
       *extension, ExtensionSystem::Get(profile()));
   results_ = management::Get::Results::Create(*info);
 
   return true;
 }
 
-bool ManagementGetPermissionWarningsByIdFunction::RunImpl() {
+bool GetPermissionWarningsByIdFunction::RunImpl() {
   scoped_ptr<management::GetPermissionWarningsById::Params> params(
       management::GetPermissionWarningsById::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
     error_ = ErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
                                                      params->id);
     return false;
   }
 
   std::vector<std::string> warnings = CreateWarningsList(extension);
   results_ = management::GetPermissionWarningsById::Results::Create(warnings);
   return true;
 }
 
 namespace {
 
-// This class helps ManagementGetPermissionWarningsByManifestFunction manage
+// This class helps GetPermissionWarningsByManifestFunction manage
 // sending manifest JSON strings to the utility process for parsing.
 class SafeManifestJSONParser : public UtilityProcessHostClient {
  public:
-  SafeManifestJSONParser(
-      ManagementGetPermissionWarningsByManifestFunction* client,
-      const std::string& manifest)
+  SafeManifestJSONParser(GetPermissionWarningsByManifestFunction* client,
+                         const std::string& manifest)
       : client_(client),
         manifest_(manifest) {}
 
   void Start() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SafeManifestJSONParser::StartWorkOnIOThread, this));
   }
@@ skipping 50 matching lines @@
     if (error_.empty() && parsed_manifest_.get())
       client_->OnParseSuccess(parsed_manifest_.release());
     else
       client_->OnParseFailure(error_);
   }
 
  private:
   ~SafeManifestJSONParser() {}
 
   // The client who we'll report results back to.
-  ManagementGetPermissionWarningsByManifestFunction* client_;
+  GetPermissionWarningsByManifestFunction* client_;
 
   // Data to parse.
   std::string manifest_;
 
   // Results of parsing.
   scoped_ptr<DictionaryValue> parsed_manifest_;
 
   std::string error_;
 };
 
 }  // namespace
 
-bool ManagementGetPermissionWarningsByManifestFunction::RunImpl() {
+bool GetPermissionWarningsByManifestFunction::RunImpl() {
   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();
 
   // Response is sent async in OnParseSuccess/Failure().
   return true;
 }
 
-void ManagementGetPermissionWarningsByManifestFunction::OnParseSuccess(
+void GetPermissionWarningsByManifestFunction::OnParseSuccess(
     DictionaryValue* parsed_manifest) {
   CHECK(parsed_manifest);
 
   scoped_refptr<Extension> extension = Extension::Create(
       FilePath(), Extension::INVALID, *parsed_manifest, Extension::NO_FLAGS,
       &error_);
   if (!extension.get()) {
     OnParseFailure(keys::kExtensionCreateError);
     return;
   }
 
   std::vector<std::string> warnings = CreateWarningsList(extension);
   results_ = management::GetPermissionWarningsByManifest::Results::Create(
       warnings);
   SendResponse(true);
 
   // Matched with AddRef() in RunImpl().
   Release();
 }
 
-void ManagementGetPermissionWarningsByManifestFunction::OnParseFailure(
+void GetPermissionWarningsByManifestFunction::OnParseFailure(
     const std::string& error) {
   error_ = error;
   SendResponse(false);
 
   // Matched with AddRef() in RunImpl().
   Release();
 }
 
-bool ManagementLaunchAppFunction::RunImpl() {
+bool LaunchAppFunction::RunImpl() {
   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,
                                                      params->id);
     return false;
   }
   if (!extension->is_app()) {
@@ skipping 11 matching lines @@
   application_launch::OpenApplication(application_launch::LaunchParams(
           profile(), extension, launch_container, NEW_FOREGROUND_TAB));
 #if !defined(OS_ANDROID)
   AppLauncherHandler::RecordAppLaunchType(
       extension_misc::APP_LAUNCH_EXTENSION_API);
 #endif
 
   return true;
 }
 
-ManagementSetEnabledFunction::ManagementSetEnabledFunction() {
+SetEnabledFunction::SetEnabledFunction() {
 }
 
-ManagementSetEnabledFunction::~ManagementSetEnabledFunction() {
+SetEnabledFunction::~SetEnabledFunction() {
 }
 
-bool ManagementSetEnabledFunction::RunImpl() {
+bool SetEnabledFunction::RunImpl() {
   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) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
@@ skipping 24 matching lines @@
       return true;
     }
     service()->EnableExtension(extension_id_);
   } else if (currently_enabled && !params->enabled) {
     service()->DisableExtension(extension_id_, Extension::DISABLE_USER_ACTION);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&ManagementSetEnabledFunction::SendResponse, this, true));
+      base::Bind(&SetEnabledFunction::SendResponse, this, true));
 
   return true;
 }
 
-void ManagementSetEnabledFunction::InstallUIProceed() {
+void SetEnabledFunction::InstallUIProceed() {
   service()->EnableExtension(extension_id_);
   SendResponse(true);
   Release();
 }
 
-void ManagementSetEnabledFunction::InstallUIAbort(bool user_initiated) {
+void SetEnabledFunction::InstallUIAbort(bool user_initiated) {
   error_ = keys::kUserDidNotReEnableError;
   SendResponse(false);
   Release();
 }
 
-ManagementUninstallFunction::ManagementUninstallFunction() {
+UninstallFunction::UninstallFunction() {
 }
 
-ManagementUninstallFunction::~ManagementUninstallFunction() {
+UninstallFunction::~UninstallFunction() {
 }
 
-bool ManagementUninstallFunction::RunImpl() {
+bool UninstallFunction::RunImpl() {
   scoped_ptr<management::Uninstall::Params> params(
       management::Uninstall::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   extension_id_ = params->id;
 
   bool show_confirm_dialog = false;
   if (params->options.get() && params->options->show_confirm_dialog.get())
     show_confirm_dialog = *params->options->show_confirm_dialog;
 
@@ skipping 21 matching lines @@
       Finish(true);
     }
   } else {
     Finish(auto_confirm_for_test == PROCEED);
   }
 
   return true;
 }
 
 // static
-void ManagementUninstallFunction::SetAutoConfirmForTest(bool should_proceed) {
+void UninstallFunction::SetAutoConfirmForTest(bool should_proceed) {
   auto_confirm_for_test = should_proceed ? PROCEED : ABORT;
 }
 
-void ManagementUninstallFunction::Finish(bool should_uninstall) {
+void UninstallFunction::Finish(bool should_uninstall) {
   if (should_uninstall) {
     bool success = service()->UninstallExtension(
         extension_id_,
         false, /* external uninstall */
         NULL);
 
     // TODO set error_ if !success
     SendResponse(success);
   } else {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kUninstallCanceledError, extension_id_);
     SendResponse(false);
   }
 
 }
 
-void ManagementUninstallFunction::ExtensionUninstallAccepted() {
+void UninstallFunction::ExtensionUninstallAccepted() {
   Finish(true);
   Release();
 }
 
-void ManagementUninstallFunction::ExtensionUninstallCanceled() {
+void UninstallFunction::ExtensionUninstallCanceled() {
   Finish(false);
   Release();
 }
 
 ManagementEventRouter::ManagementEventRouter(Profile* profile)
     : profile_(profile) {
   int types[] = {
     chrome::NOTIFICATION_EXTENSION_INSTALLED,
     chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
     chrome::NOTIFICATION_EXTENSION_LOADED,
@@ skipping 84 matching lines @@
 ProfileKeyedAPIFactory<ManagementAPI>* ManagementAPI::GetFactoryInstance() {
   return &g_factory.Get();
 }
 
 void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
   management_event_router_.reset(new ManagementEventRouter(profile_));
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
 
 }  // namespace extensions