Move webstore_private 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 "apps/app_launcher.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 188 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() {
   base::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(base::ListValue* extensions,
-                                           BundleInstaller::ItemList* items) {
+bool WebstorePrivateInstallBundleFunction::
+    ReadBundleInfo(base::ListValue* extensions,
+    BundleInstaller::ItemList* items) {
   for (size_t i = 0; i < extensions->GetSize(); ++i) {
     base::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()
+WebstorePrivateBeginInstallWithManifest3Function::
+    WebstorePrivateBeginInstallWithManifest3Function()
     : use_app_installed_bubble_(false), enable_launcher_(false) {}
 
-BeginInstallWithManifestFunction::~BeginInstallWithManifestFunction() {}
+WebstorePrivateBeginInstallWithManifest3Function::
+    ~WebstorePrivateBeginInstallWithManifest3Function() {}
 
-bool BeginInstallWithManifestFunction::RunImpl() {
+bool WebstorePrivateBeginInstallWithManifest3Function::RunImpl() {
   base::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 55 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(std::string()));
       break;
     case UNKNOWN_ERROR:
       SetResult(Value::CreateStringValue("unknown_error"));
       break;
     case USER_CANCELLED:
       SetResult(Value::CreateStringValue("user_cancelled"));
       break;
@@ skipping 16 matching lines @@
       SetResult(Value::CreateStringValue("signin_failed"));
       break;
     case ALREADY_INSTALLED:
       SetResult(Value::CreateStringValue("already_installed"));
       break;
     default:
       CHECK(false);
   }
 }
 
-void BeginInstallWithManifestFunction::OnWebstoreParseSuccess(
+void WebstorePrivateBeginInstallWithManifest3Function::OnWebstoreParseSuccess(
     const std::string& id,
     const SkBitmap& icon,
     base::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 17 matching lines @@
       signin_manager &&
       signin_manager->GetAuthenticatedUsername().empty() &&
       signin_manager->AuthInProgress()) {
     signin_tracker_.reset(new SigninTracker(profile(), this));
     return;
   }
 
   SigninCompletedOrNotNeeded();
 }
 
-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;
   g_pending_installs.Get().EraseInstall(profile_, id);
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-void BeginInstallWithManifestFunction::SigninFailed(
+void WebstorePrivateBeginInstallWithManifest3Function::SigninFailed(
     const GoogleServiceAuthError& error) {
   signin_tracker_.reset();
 
   SetResultCode(SIGNIN_FAILED);
   error_ = error.ToString();
   g_pending_installs.Get().EraseInstall(profile_, id_);
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-void BeginInstallWithManifestFunction::SigninSuccess() {
+void WebstorePrivateBeginInstallWithManifest3Function::SigninSuccess() {
   signin_tracker_.reset();
 
   SigninCompletedOrNotNeeded();
 }
 
-void BeginInstallWithManifestFunction::SigninCompletedOrNotNeeded() {
+void WebstorePrivateBeginInstallWithManifest3Function::
+    SigninCompletedOrNotNeeded() {
   content::WebContents* web_contents = GetAssociatedWebContents();
   if (!web_contents)  // The browser window has gone away.
     return;
   install_prompt_.reset(new ExtensionInstallPrompt(web_contents));
   install_prompt_->ConfirmWebstoreInstall(
       this,
       dummy_extension_.get(),
       &icon_,
       ExtensionInstallPrompt::GetDefaultShowDialogCallback());
   // Control flow finishes up in InstallUIProceed or InstallUIAbort.
 }
 
-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->enable_launcher = enable_launcher_;
   // If we are enabling the launcher, we should not show the app list in order
   // to train the user to open it themselves at least once.
   approval->skip_post_install_ui = enable_launcher_;
   approval->installing_icon = gfx::ImageSkia::CreateFrom1xBitmap(icon_);
   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_.get(), "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);
   g_pending_installs.Get().EraseInstall(profile_, id_);
   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_.get(),
                                                       histogram_name.c_str());
 
   histogram_name = user_initiated ?
       "Extensions.Permissions_InstallCancel" :
       "Extensions.Permissions_InstallAbort";
   ExtensionService::RecordPermissionMessagesHistogram(dummy_extension_.get(),
                                                       histogram_name.c_str());
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-CompleteInstallFunction::CompleteInstallFunction() {}
+WebstorePrivateCompleteInstallFunction::
+    WebstorePrivateCompleteInstallFunction() {}
 
-CompleteInstallFunction::~CompleteInstallFunction() {}
+WebstorePrivateCompleteInstallFunction::
+    ~WebstorePrivateCompleteInstallFunction() {}
 
-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;
   }
 
   approval_ = g_pending_approvals.Get().PopApproval(profile(), id).Pass();
   if (!approval_) {
     error_ = ErrorUtils::FormatErrorMessage(
@@ skipping 18 matching lines @@
   // 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);
 
   LOG(INFO) << "Install success, sending response";
   g_pending_installs.Get().EraseInstall(profile_, 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;
   LOG(INFO) << "Install failed, sending response";
   g_pending_installs.Get().EraseInstall(profile_, id);
   SendResponse(false);
 
   // Matches the AddRef in RunImpl().
   Release();
 }
 
-EnableAppLauncherFunction::EnableAppLauncherFunction() {}
+WebstorePrivateEnableAppLauncherFunction::
+    WebstorePrivateEnableAppLauncherFunction() {}
 
-EnableAppLauncherFunction::~EnableAppLauncherFunction() {}
+WebstorePrivateEnableAppLauncherFunction::
+    ~WebstorePrivateEnableAppLauncherFunction() {}
 
-bool EnableAppLauncherFunction::RunImpl() {
+bool WebstorePrivateEnableAppLauncherFunction::RunImpl() {
   AppListService::Get()->EnableAppList(profile());
   SendResponse(true);
   return true;
 }
 
-bool GetBrowserLoginFunction::RunImpl() {
+bool WebstorePrivateGetBrowserLoginFunction::RunImpl() {
   SetResult(CreateLoginResult(profile_->GetOriginalProfile()));
   return true;
 }
 
-bool GetStoreLoginFunction::RunImpl() {
+bool WebstorePrivateGetStoreLoginFunction::RunImpl() {
   SetResult(Value::CreateStringValue(GetWebstoreLogin(profile_)));
   return true;
 }
 
-bool SetStoreLoginFunction::RunImpl() {
+bool WebstorePrivateSetStoreLoginFunction::RunImpl() {
   std::string login;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &login));
   SetWebstoreLogin(profile_, login);
   return true;
 }
 
-GetWebGLStatusFunction::GetWebGLStatusFunction() {
+WebstorePrivateGetWebGLStatusFunction::WebstorePrivateGetWebGLStatusFunction() {
   feature_checker_ = new GPUFeatureChecker(
       gpu::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);
 }
 
-bool GetIsLauncherEnabledFunction::RunImpl() {
+bool WebstorePrivateGetIsLauncherEnabledFunction::RunImpl() {
   SetResult(Value::CreateBooleanValue(apps::IsAppLauncherEnabled()));
   SendResponse(true);
   return true;
 }
 
-bool IsInIncognitoModeFunction::RunImpl() {
+bool WebstorePrivateIsInIncognitoModeFunction::RunImpl() {
   SetResult(
       Value::CreateBooleanValue(profile_ != profile_->GetOriginalProfile()));
   SendResponse(true);
   return true;
 }
 
 }  // namespace extensions