Move API functions registrations out of ExtensionFunctionRegistry.

chrome/browser/extensions/api/webstore_private/webstore_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/webstore_private/webstore_private_api.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 109 matching lines @@
   test_webstore_installer_delegate = delegate;
 }
 
 // static
 scoped_ptr<WebstoreInstaller::Approval>
     WebstorePrivateApi::PopApprovalForTesting(
         Profile* profile, const std::string& extension_id) {
   return g_pending_approvals.Get().PopApproval(profile, extension_id);
 }
 
-InstallBundleFunction::InstallBundleFunction() {}
-InstallBundleFunction::~InstallBundleFunction() {}
+WebstorePrivateInstallBundleFunction::WebstorePrivateInstallBundleFunction() {}
+WebstorePrivateInstallBundleFunction::~WebstorePrivateInstallBundleFunction() {}
 
-bool InstallBundleFunction::RunImpl() {
+bool WebstorePrivateInstallBundleFunction::RunImpl() {
   ListValue* extensions = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(0, &extensions));
 
   BundleInstaller::ItemList items;
   if (!ReadBundleInfo(extensions, &items))
     return false;
 
   bundle_ = new BundleInstaller(GetCurrentBrowser(), items);
 
   AddRef();  // Balanced in OnBundleInstallCompleted / OnBundleInstallCanceled.
 
   bundle_->PromptForApproval(this);
   return true;
 }
 
-bool InstallBundleFunction::ReadBundleInfo(ListValue* extensions,
+bool WebstorePrivateInstallBundleFunction::ReadBundleInfo(ListValue* extensions,
                                            BundleInstaller::ItemList* items) {
   for (size_t i = 0; i < extensions->GetSize(); ++i) {
     DictionaryValue* details = NULL;
     EXTENSION_FUNCTION_VALIDATE(extensions->GetDictionary(i, &details));
 
     BundleInstaller::Item item;
     EXTENSION_FUNCTION_VALIDATE(details->GetString(
         kIdKey, &item.id));
     EXTENSION_FUNCTION_VALIDATE(details->GetString(
         kManifestKey, &item.manifest));
     EXTENSION_FUNCTION_VALIDATE(details->GetString(
         kLocalizedNameKey, &item.localized_name));
 
     items->push_back(item);
   }
 
   return true;
 }
 
-void InstallBundleFunction::OnBundleInstallApproved() {
+void WebstorePrivateInstallBundleFunction::OnBundleInstallApproved() {
   bundle_->CompleteInstall(
       &(dispatcher()->delegate()->GetAssociatedWebContents()->GetController()),
       this);
 }
 
-void InstallBundleFunction::OnBundleInstallCanceled(bool user_initiated) {
+void WebstorePrivateInstallBundleFunction::OnBundleInstallCanceled(
+    bool user_initiated) {
   if (user_initiated)
     error_ = "user_canceled";
   else
     error_ = "unknown_error";
 
   SendResponse(false);
 
   Release();  // Balanced in RunImpl().
 }
 
-void InstallBundleFunction::OnBundleInstallCompleted() {
+void WebstorePrivateInstallBundleFunction::OnBundleInstallCompleted() {
   SendResponse(true);
 
   Release();  // Balanced in RunImpl().
 }
 
-BeginInstallWithManifestFunction::BeginInstallWithManifestFunction()
-    : use_app_installed_bubble_(false) {}
+WebstorePrivateBeginInstallWithManifest3Function::
+    WebstorePrivateBeginInstallWithManifest3Function()
+        : use_app_installed_bubble_(false) {}
 
-BeginInstallWithManifestFunction::~BeginInstallWithManifestFunction() {}
+WebstorePrivateBeginInstallWithManifest3Function::
+    ~WebstorePrivateBeginInstallWithManifest3Function() {}
 
-bool BeginInstallWithManifestFunction::RunImpl() {
+bool WebstorePrivateBeginInstallWithManifest3Function::RunImpl() {
   DictionaryValue* details = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
   CHECK(details);
 
   EXTENSION_FUNCTION_VALIDATE(details->GetString(kIdKey, &id_));
   if (!extensions::Extension::IdIsValid(id_)) {
     SetResultCode(INVALID_ID);
     error_ = kInvalidIdError;
     return false;
   }
@@ skipping 42 matching lines @@
 
   // Matched with a Release in OnWebstoreParseSuccess/OnWebstoreParseFailure.
   AddRef();
 
   // The response is sent asynchronously in OnWebstoreParseSuccess/
   // OnWebstoreParseFailure.
   return true;
 }
 
 
-void BeginInstallWithManifestFunction::SetResultCode(ResultCode code) {
+void WebstorePrivateBeginInstallWithManifest3Function::SetResultCode(
+    ResultCode code) {
   switch (code) {
     case ERROR_NONE:
       SetResult(Value::CreateStringValue(""));
       break;
     case UNKNOWN_ERROR:
       SetResult(Value::CreateStringValue("unknown_error"));
       break;
     case USER_CANCELLED:
       SetResult(Value::CreateStringValue("user_cancelled"));
       break;
@@ skipping 10 matching lines @@
       SetResult(Value::CreateStringValue("permission_denied"));
       break;
     case INVALID_ICON_URL:
       SetResult(Value::CreateStringValue("invalid_icon_url"));
       break;
     default:
       CHECK(false);
   }
 }
 
-void BeginInstallWithManifestFunction::OnWebstoreParseSuccess(
+void WebstorePrivateBeginInstallWithManifest3Function::OnWebstoreParseSuccess(
     const std::string& id,
     const SkBitmap& icon,
     DictionaryValue* parsed_manifest) {
   CHECK_EQ(id_, id);
   CHECK(parsed_manifest);
   icon_ = icon;
   parsed_manifest_.reset(parsed_manifest);
 
   std::string error;
   dummy_extension_ = ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
@@ skipping 15 matching lines @@
     return;
   install_prompt_.reset(new ExtensionInstallPrompt(web_contents));
   install_prompt_->ConfirmWebstoreInstall(
       this,
       dummy_extension_,
       &icon_,
       ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   // Control flow finishes up in InstallUIProceed or InstallUIAbort.
 }
 
-void BeginInstallWithManifestFunction::OnWebstoreParseFailure(
+void WebstorePrivateBeginInstallWithManifest3Function::OnWebstoreParseFailure(
     const std::string& id,
     WebstoreInstallHelper::Delegate::InstallHelperResultCode result_code,
     const std::string& error_message) {
   CHECK_EQ(id_, id);
 
   // Map from WebstoreInstallHelper's result codes to ours.
   switch (result_code) {
     case WebstoreInstallHelper::Delegate::UNKNOWN_ERROR:
       SetResultCode(UNKNOWN_ERROR);
       break;
     case WebstoreInstallHelper::Delegate::ICON_ERROR:
       SetResultCode(ICON_ERROR);
       break;
     case WebstoreInstallHelper::Delegate::MANIFEST_ERROR:
       SetResultCode(MANIFEST_ERROR);
       break;
     default:
       CHECK(false);
   }
   error_ = error_message;
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-void BeginInstallWithManifestFunction::InstallUIProceed() {
+void WebstorePrivateBeginInstallWithManifest3Function::InstallUIProceed() {
   // This gets cleared in CrxInstaller::ConfirmInstall(). TODO(asargent) - in
   // the future we may also want to add time-based expiration, where a whitelist
   // entry is only valid for some number of minutes.
   scoped_ptr<WebstoreInstaller::Approval> approval(
       WebstoreInstaller::Approval::CreateWithNoInstallPrompt(
           profile(), id_, parsed_manifest_.Pass()));
   approval->use_app_installed_bubble = use_app_installed_bubble_;
   approval->record_oauth2_grant = install_prompt_->record_oauth2_grant();
   g_pending_approvals.Get().PushApproval(approval.Pass());
 
   SetResultCode(ERROR_NONE);
   SendResponse(true);
 
   // The Permissions_Install histogram is recorded from the ExtensionService
   // for all extension installs, so we only need to record the web store
   // specific histogram here.
   ExtensionService::RecordPermissionMessagesHistogram(
       dummy_extension_, "Extensions.Permissions_WebStoreInstall");
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-void BeginInstallWithManifestFunction::InstallUIAbort(bool user_initiated) {
+void WebstorePrivateBeginInstallWithManifest3Function::InstallUIAbort(
+    bool user_initiated) {
   error_ = kUserCancelledError;
   SetResultCode(USER_CANCELLED);
   SendResponse(false);
 
   // The web store install histograms are a subset of the install histograms.
   // We need to record both histograms here since CrxInstaller::InstallUIAbort
   // is never called for web store install cancellations.
   std::string histogram_name = user_initiated ?
       "Extensions.Permissions_WebStoreInstallCancel" :
       "Extensions.Permissions_WebStoreInstallAbort";
   ExtensionService::RecordPermissionMessagesHistogram(
       dummy_extension_, histogram_name.c_str());
 
   histogram_name = user_initiated ?
       "Extensions.Permissions_InstallCancel" :
       "Extensions.Permissions_InstallAbort";
   ExtensionService::RecordPermissionMessagesHistogram(
       dummy_extension_, histogram_name.c_str());
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-bool CompleteInstallFunction::RunImpl() {
+bool WebstorePrivateCompleteInstallFunction::RunImpl() {
   std::string id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &id));
   if (!extensions::Extension::IdIsValid(id)) {
     error_ = kInvalidIdError;
     return false;
   }
 
   scoped_ptr<WebstoreInstaller::Approval> approval(
       g_pending_approvals.Get().PopApproval(profile(), id));
   if (!approval.get()) {
     error_ = ErrorUtils::FormatErrorMessage(
         kNoPreviousBeginInstallWithManifestError, id);
     return false;
   }
 
   AddRef();
 
   // The extension will install through the normal extension install flow, but
   // the whitelist entry will bypass the normal permissions install dialog.
   scoped_refptr<WebstoreInstaller> installer = new WebstoreInstaller(
       profile(), this,
       &(dispatcher()->delegate()->GetAssociatedWebContents()->GetController()),
       id, approval.Pass(), WebstoreInstaller::FLAG_NONE);
   installer->Start();
 
   return true;
 }
 
-void CompleteInstallFunction::OnExtensionInstallSuccess(
+void WebstorePrivateCompleteInstallFunction::OnExtensionInstallSuccess(
     const std::string& id) {
   if (test_webstore_installer_delegate)
     test_webstore_installer_delegate->OnExtensionInstallSuccess(id);
 
   SendResponse(true);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-void CompleteInstallFunction::OnExtensionInstallFailure(
+void WebstorePrivateCompleteInstallFunction::OnExtensionInstallFailure(
     const std::string& id,
     const std::string& error,
     WebstoreInstaller::FailureReason reason) {
   if (test_webstore_installer_delegate) {
     test_webstore_installer_delegate->OnExtensionInstallFailure(
         id, error, reason);
   }
 
   error_ = error;
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
 
-bool GetBrowserLoginFunction::RunImpl() {
+bool WebstorePrivateGetBrowserLoginFunction::RunImpl() {
   SetResult(CreateLoginResult(profile_->GetOriginalProfile()));
   return true;
 }
 
-bool GetStoreLoginFunction::RunImpl() {
+bool WebstorePrivateGetStoreLoginFunction::RunImpl() {
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   ExtensionPrefs* prefs = service->extension_prefs();
   std::string login;
   if (prefs->GetWebStoreLogin(&login)) {
     SetResult(Value::CreateStringValue(login));
   } else {
     SetResult(Value::CreateStringValue(std::string()));
   }
   return true;
 }
 
-bool SetStoreLoginFunction::RunImpl() {
+bool WebstorePrivateSetStoreLoginFunction::RunImpl() {
   std::string login;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &login));
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   ExtensionPrefs* prefs = service->extension_prefs();
   prefs->SetWebStoreLogin(login);
   return true;
 }
 
-GetWebGLStatusFunction::GetWebGLStatusFunction() {
+WebstorePrivateGetWebGLStatusFunction::WebstorePrivateGetWebGLStatusFunction() {
   feature_checker_ = new GPUFeatureChecker(
       content::GPU_FEATURE_TYPE_WEBGL,
-      base::Bind(&GetWebGLStatusFunction::OnFeatureCheck,
+      base::Bind(&WebstorePrivateGetWebGLStatusFunction::OnFeatureCheck,
           base::Unretained(this)));
 }
 
-GetWebGLStatusFunction::~GetWebGLStatusFunction() {}
+WebstorePrivateGetWebGLStatusFunction::
+    ~WebstorePrivateGetWebGLStatusFunction() {}
 
-void GetWebGLStatusFunction::CreateResult(bool webgl_allowed) {
+void WebstorePrivateGetWebGLStatusFunction::CreateResult(bool webgl_allowed) {
   SetResult(Value::CreateStringValue(
       webgl_allowed ? "webgl_allowed" : "webgl_blocked"));
 }
 
-bool GetWebGLStatusFunction::RunImpl() {
+bool WebstorePrivateGetWebGLStatusFunction::RunImpl() {
   feature_checker_->CheckGPUFeatureAvailability();
   return true;
 }
 
-void GetWebGLStatusFunction::OnFeatureCheck(bool feature_allowed) {
+void WebstorePrivateGetWebGLStatusFunction::OnFeatureCheck(
+    bool feature_allowed) {
   CreateResult(feature_allowed);
   SendResponse(true);
 }
 
 }  // namespace extensions