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

chrome/browser/extensions/external_install_error.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/external_install_error.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 242 matching lines @@
 
 base::string16 ExternalInstallBubbleAlert::GetBubbleViewCancelButtonLabel() {
   return prompt_->GetAbortButtonLabel();
 }
 
 void ExternalInstallBubbleAlert::OnBubbleViewDidClose(Browser* browser) {
 }
 
 void ExternalInstallBubbleAlert::BubbleViewAcceptButtonPressed(
     Browser* browser) {
-  error_->InstallUIProceed();
+  error_->OnInstallPromptDone(ExtensionInstallPrompt::Result::ACCEPTED);
 }
 
 void ExternalInstallBubbleAlert::BubbleViewCancelButtonPressed(
     Browser* browser) {
-  error_->InstallUIAbort(true);
+  error_->OnInstallPromptDone(ExtensionInstallPrompt::Result::USER_CANCELED);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ExternalInstallError
 
 ExternalInstallError::ExternalInstallError(
     content::BrowserContext* browser_context,
     const std::string& extension_id,
@@ skipping 12 matching lines @@
   webstore_data_fetcher_.reset(new WebstoreDataFetcher(
       this, browser_context_->GetRequestContext(), GURL(), extension_id_));
   webstore_data_fetcher_->Start();
 }
 
 ExternalInstallError::~ExternalInstallError() {
   if (global_error_.get())
     error_service_->RemoveGlobalError(global_error_.get());
 }
 
-void ExternalInstallError::InstallUIProceed() {
+void ExternalInstallError::OnInstallPromptDone(
+    ExtensionInstallPrompt::Result result) {
   const Extension* extension = GetExtension();
-  if (extension) {
-    ExtensionSystem::Get(browser_context_)
-        ->extension_service()
-        ->GrantPermissionsAndEnableExtension(extension);
-    // Since the manager listens for the extension to be loaded, this will
-    // remove the error...
-  } else {
-    // ... Otherwise we have to do it explicitly.
+  bool did_remove_error = false;
+  switch (result) {
+    case ExtensionInstallPrompt::Result::ACCEPTED:
+      if (extension) {
+        ExtensionSystem::Get(browser_context_)
+            ->extension_service()
+            ->GrantPermissionsAndEnableExtension(extension);
+        // Since the manager listens for the extension to be loaded, this will
+        // remove the error.
+        did_remove_error = true;
+      }
+      break;
+    case ExtensionInstallPrompt::Result::USER_CANCELED:
+      if (extension) {
+        ExtensionSystem::Get(browser_context_)
+            ->extension_service()
+            ->UninstallExtension(extension_id_,
+                                 extensions::UNINSTALL_REASON_INSTALL_CANCELED,
+                                 base::Bind(&base::DoNothing),
+                                 nullptr);  // Ignore error.
+        did_remove_error = true;
+      }
+      break;
+    case ExtensionInstallPrompt::Result::ABORTED:
+      break;
+  }
+  if (!did_remove_error)
     manager_->RemoveExternalInstallError();
-  }
-}
-
-void ExternalInstallError::InstallUIAbort(bool user_initiated) {
-  if (user_initiated && GetExtension()) {
-    ExtensionSystem::Get(browser_context_)
-        ->extension_service()
-        ->UninstallExtension(extension_id_,
-                             extensions::UNINSTALL_REASON_INSTALL_CANCELED,
-                             base::Bind(&base::DoNothing),
-                             NULL);  // Ignore error.
-    // Since the manager listens for the extension to be removed, this will
-    // remove the error...
-  } else {
-    // ... Otherwise we have to do it explicitly.
-    manager_->RemoveExternalInstallError();
-  }
 }
 
 void ExternalInstallError::ShowDialog(Browser* browser) {
   DCHECK(install_ui_.get());
   DCHECK(prompt_.get());
   DCHECK(browser);
   content::WebContents* web_contents = NULL;
   web_contents = browser->tab_strip_model()->GetActiveWebContents();
   install_ui_show_params_.reset(
       new ExtensionInstallPromptShowParams(web_contents));
   ExtensionInstallPrompt::GetDefaultShowDialogCallback().Run(
-      install_ui_show_params_.get(), this, std::move(prompt_));
+      install_ui_show_params_.get(),
+      base::Bind(&ExternalInstallError::OnInstallPromptDone,
+                 weak_factory_.GetWeakPtr()),
+      std::move(prompt_));
 }
 
 const Extension* ExternalInstallError::GetExtension() const {
   return ExtensionRegistry::Get(browser_context_)
       ->GetExtensionById(extension_id_, ExtensionRegistry::EVERYTHING);
 }
 
 void ExternalInstallError::OnWebstoreRequestFailure() {
   OnFetchComplete();
 }
@@ skipping 26 matching lines @@
 }
 
 void ExternalInstallError::OnFetchComplete() {
   // Create a new ExtensionInstallPrompt. We pass in NULL for the UI
   // components because we display at a later point, and don't want
   // to pass ones which may be invalidated.
   install_ui_.reset(
       new ExtensionInstallPrompt(Profile::FromBrowserContext(browser_context_),
                                  NULL));  // NULL native window.
 
-  install_ui_->ShowDialog(this, GetExtension(),
+  install_ui_->ShowDialog(base::Bind(&ExternalInstallError::OnInstallPromptDone,
+                                     weak_factory_.GetWeakPtr()),
+                          GetExtension(),
                           nullptr,  // Force a fetch of the icon.
                           std::move(prompt_),
                           base::Bind(&ExternalInstallError::OnDialogReady,
                                      weak_factory_.GetWeakPtr()));
 }
 
 void ExternalInstallError::OnDialogReady(
     ExtensionInstallPromptShowParams* show_params,
-    ExtensionInstallPrompt::Delegate* prompt_delegate,
+    const ExtensionInstallPrompt::DoneCallback& callback,
     scoped_ptr<ExtensionInstallPrompt::Prompt> prompt) {
-  DCHECK_EQ(this, prompt_delegate);
   prompt_ = std::move(prompt);
 
   if (alert_type_ == BUBBLE_ALERT) {
     global_error_.reset(new ExternalInstallBubbleAlert(this, prompt_.get()));
     error_service_->AddGlobalError(global_error_.get());
 
     Browser* browser =
         chrome::FindTabbedBrowser(Profile::FromBrowserContext(browser_context_),
                                   true,
                                   chrome::GetActiveDesktop());
     if (browser)
       global_error_->ShowBubbleView(browser);
   } else {
     DCHECK(alert_type_ == MENU_ALERT);
     global_error_.reset(new ExternalInstallMenuAlert(this));
     error_service_->AddGlobalError(global_error_.get());
   }
 }
 
 }  // namespace extensions