[Extensions] Migrate ExtensionInstallPrompt::Delegate to be a callback

extensions/browser/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 "extensions/browser/api/management/management_api.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 433 matching lines @@
   bool currently_enabled =
       registry->enabled_extensions().Contains(extension_id_) ||
       registry->terminated_extensions().Contains(extension_id_);
 
   if (!currently_enabled && enabled) {
     ExtensionPrefs* prefs = ExtensionPrefs::Get(browser_context());
     if (prefs->DidExtensionEscalatePermissions(extension_id_)) {
       if (!user_gesture())
         return RespondNow(Error(keys::kGestureNeededForEscalationError));
 
-      AddRef();  // Matched in InstallUIProceed/InstallUIAbort
-      install_prompt_ = delegate->SetEnabledFunctionDelegate(this, extension);
+      AddRef();  // Matched in OnInstallPromptDone().
+      install_prompt_ = delegate->SetEnabledFunctionDelegate(
+          GetSenderWebContents(), browser_context(), extension,
+          base::Bind(&ManagementSetEnabledFunction::OnInstallPromptDone, this));
       return RespondLater();
     }
     if (prefs->GetDisableReasons(extension_id_) &
             Extension::DISABLE_UNSUPPORTED_REQUIREMENT) {
       // Recheck the requirements.
       requirements_checker_ = delegate->CreateRequirementsChecker();
       requirements_checker_->Check(
           extension,
           base::Bind(&ManagementSetEnabledFunction::OnRequirementsChecked,
                      this));  // This bind creates a reference.
       return RespondLater();
     }
     delegate->EnableExtension(browser_context(), extension_id_);
   } else if (currently_enabled && !params->enabled) {
     delegate->DisableExtension(browser_context(), extension_id_,
                                Extension::DISABLE_USER_ACTION);
   }
 
   return RespondNow(NoArguments());
 }
 
-void ManagementSetEnabledFunction::InstallUIProceed() {
-  ManagementAPI::GetFactoryInstance()
-      ->Get(browser_context())
-      ->GetDelegate()
-      ->EnableExtension(browser_context(), extension_id_);
-  Respond(OneArgument(new base::FundamentalValue(true)));
-  Release();
-}
+void ManagementSetEnabledFunction::OnInstallPromptDone(bool did_accept) {
+  if (did_accept) {
+    ManagementAPI::GetFactoryInstance()
+        ->Get(browser_context())
+        ->GetDelegate()
+        ->EnableExtension(browser_context(), extension_id_);
+    Respond(OneArgument(new base::FundamentalValue(true)));
+  } else {
+    Respond(Error(keys::kUserDidNotReEnableError));
+  }
 
-void ManagementSetEnabledFunction::InstallUIAbort(bool user_initiated) {
-  Respond(Error(keys::kUserDidNotReEnableError));
-  Release();
+  Release();  // Balanced in Run().
 }
 
 void ManagementSetEnabledFunction::OnRequirementsChecked(
     const std::vector<std::string>& requirements_errors) {
   if (requirements_errors.empty()) {
     ManagementAPI::GetFactoryInstance()->Get(browser_context())->GetDelegate()->
         EnableExtension(browser_context(), extension_id_);
     Respond(NoArguments());
   } else {
     // TODO(devlin): Should we really be noisy here all the time?
@@ skipping 403 matching lines @@
 ManagementAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
   management_event_router_.reset(new ManagementEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions