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

chrome/browser/extensions/extension_reenabler.cc

 // Copyright 2014 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/extension_reenabler.h"
 
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/webstore_data_fetcher.h"
 #include "chrome/browser/extensions/webstore_inline_installer.h"
@@ skipping 52 matching lines @@
     const GURL& referrer_url,
     const Callback& callback,
     content::WebContents* web_contents,
     const ExtensionInstallPrompt::ShowDialogCallback& show_dialog_callback)
     : extension_(extension),
       browser_context_(browser_context),
       referrer_url_(referrer_url),
       callback_(callback),
       show_dialog_callback_(show_dialog_callback),
       finished_(false),
-      registry_observer_(this) {
+      registry_observer_(this),
+      weak_factory_(this) {
   DCHECK(extension_.get());
   registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 
   install_prompt_.reset(new ExtensionInstallPrompt(web_contents));
 
   // If we have a non-empty referrer, then we have to validate that it's a valid
   // url for the extension.
   if (!referrer_url_.is_empty()) {
     webstore_data_fetcher_.reset(new WebstoreDataFetcher(
         this,
         browser_context_->GetRequestContext(),
         referrer_url_,
         extension->id()));
     webstore_data_fetcher_->Start();
   } else {
     ExtensionInstallPrompt::PromptType type =
         ExtensionInstallPrompt::GetReEnablePromptTypeForExtension(
             browser_context, extension.get());
     install_prompt_->ShowDialog(
-        this, extension.get(), nullptr,
+        base::Bind(&ExtensionReenabler::OnInstallPromptDone,
+                   weak_factory_.GetWeakPtr()),
+        extension.get(), nullptr,
         make_scoped_ptr(new ExtensionInstallPrompt::Prompt(type)),
         show_dialog_callback_);
   }
 }
 
-void ExtensionReenabler::InstallUIProceed() {
-  // Stop observing - we don't want to see our own enablement.
-  registry_observer_.RemoveAll();
+void ExtensionReenabler::OnInstallPromptDone(
+    ExtensionInstallPrompt::Result install_result) {
+  ReenableResult result = ABORTED;
+  switch (install_result) {
+    case ExtensionInstallPrompt::Result::ACCEPTED: {
+      // Stop observing - we don't want to see our own enablement.
+      registry_observer_.RemoveAll();
 
-  ExtensionService* extension_service =
-      ExtensionSystem::Get(browser_context_)->extension_service();
-  if (extension_service->browser_terminating()) {
-    Finish(ABORTED);
-  } else {
-    extension_service->GrantPermissionsAndEnableExtension(extension_.get());
-    // The re-enable could have failed if the extension is disallowed by
-    // policy.
-    bool enabled = ExtensionRegistry::Get(browser_context_)->
-        enabled_extensions().GetByID(extension_->id()) != nullptr;
-    Finish(enabled ? REENABLE_SUCCESS : NOT_ALLOWED);
+      ExtensionService* extension_service =
+          ExtensionSystem::Get(browser_context_)->extension_service();
+      if (extension_service->browser_terminating()) {
+        result = ABORTED;
+      } else {
+        extension_service->GrantPermissionsAndEnableExtension(extension_.get());
+        // The re-enable could have failed if the extension is disallowed by
+        // policy.
+        bool enabled = ExtensionRegistry::Get(browser_context_)
+                           ->enabled_extensions()
+                           .GetByID(extension_->id()) != nullptr;
+        result = enabled ? REENABLE_SUCCESS : NOT_ALLOWED;
+      }
+      break;
+    }
+    case ExtensionInstallPrompt::Result::USER_CANCELED:
+      result = USER_CANCELED;
+      break;
+    case ExtensionInstallPrompt::Result::ABORTED:
+      result = ABORTED;
+      break;
   }
-}
 
-void ExtensionReenabler::InstallUIAbort(bool user_initiated) {
-  Finish(user_initiated ? USER_CANCELED : ABORTED);
+  Finish(result);
 }
 
 void ExtensionReenabler::OnExtensionLoaded(
     content::BrowserContext* browser_context,
     const Extension* extension) {
   // If the user chose to manually re-enable the extension then, for all
   // intents and purposes, this was a success.
   if (extension == extension_.get())
     Finish(REENABLE_SUCCESS);
 }
@@ skipping 16 matching lines @@
   std::string error;
   if (!WebstoreInlineInstaller::IsRequestorPermitted(*webstore_data,
                                                      referrer_url_,
                                                      &error)) {
     Finish(NOT_ALLOWED);
   } else {
     ExtensionInstallPrompt::PromptType type =
         ExtensionInstallPrompt::GetReEnablePromptTypeForExtension(
             browser_context_, extension_.get());
     install_prompt_->ShowDialog(
-        this, extension_.get(), nullptr,
+        base::Bind(&ExtensionReenabler::OnInstallPromptDone,
+                   weak_factory_.GetWeakPtr()),
+        extension_.get(), nullptr,
         make_scoped_ptr(new ExtensionInstallPrompt::Prompt(type)),
         show_dialog_callback_);
   }
 }
 
 void ExtensionReenabler::OnWebstoreResponseParseFailure(
     const std::string& error) {
   Finish(ABORTED);
 }
 
 void ExtensionReenabler::Finish(ReenableResult result) {
   DCHECK(!finished_);
   finished_ = true;
   registry_observer_.RemoveAll();
   callback_.Run(result);
 }
 
 }  // namespace extensions