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

chrome/browser/extensions/extension_install_prompt.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/extension_install_prompt.h"
 
 #include <utility>
 
+#include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/bundle_installer.h"
 #include "chrome/browser/extensions/extension_install_prompt_show_params.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 120 matching lines @@
 SkBitmap GetDefaultIconBitmapForMaxScaleFactor(bool is_app) {
   const gfx::ImageSkia& image = is_app ?
       extensions::util::GetDefaultAppIcon() :
       extensions::util::GetDefaultExtensionIcon();
   return image.GetRepresentation(
       gfx::ImageSkia::GetMaxSupportedScale()).sk_bitmap();
 }
 
 // If auto confirm is enabled then posts a task to proceed with or cancel the
 // install and returns true. Otherwise returns false.
-bool AutoConfirmPrompt(ExtensionInstallPrompt::Delegate* delegate) {
+bool AutoConfirmPrompt(ExtensionInstallPrompt::DoneCallback* callback) {
   switch (extensions::ScopedTestDialogAutoConfirm::GetAutoConfirmValue()) {
     case extensions::ScopedTestDialogAutoConfirm::NONE:
       return false;
-    // We use PostTask instead of calling the delegate directly here, because in
+    // We use PostTask instead of calling the callback directly here, because in
     // the real implementations it's highly likely the message loop will be
     // pumping a few times before the user clicks accept or cancel.
     case extensions::ScopedTestDialogAutoConfirm::ACCEPT:
       base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(&ExtensionInstallPrompt::Delegate::InstallUIProceed,
-                     base::Unretained(delegate)));
+          FROM_HERE, base::Bind(base::ResetAndReturn(callback),
+                                ExtensionInstallPrompt::Result::ACCEPTED));
       return true;
     case extensions::ScopedTestDialogAutoConfirm::CANCEL:
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(&ExtensionInstallPrompt::Delegate::InstallUIAbort,
-                     base::Unretained(delegate),
-                     true));
+          FROM_HERE, base::Bind(base::ResetAndReturn(callback),
+                                ExtensionInstallPrompt::Result::USER_CANCELED));
       return true;
   }
 
   NOTREACHED();
   return false;
 }
 
 Profile* ProfileForWebContents(content::WebContents* web_contents) {
   if (!web_contents)
     return NULL;
@@ skipping 439 matching lines @@
       error);
 }
 
 ExtensionInstallPrompt::ExtensionInstallPrompt(content::WebContents* contents)
     : profile_(ProfileForWebContents(contents)),
       ui_loop_(base::MessageLoop::current()),
       extension_(NULL),
       install_ui_(extensions::CreateExtensionInstallUI(
           ProfileForWebContents(contents))),
       show_params_(new ExtensionInstallPromptShowParams(contents)),
-      delegate_(NULL),
       did_call_show_dialog_(false) {
 }
 
 ExtensionInstallPrompt::ExtensionInstallPrompt(Profile* profile,
                                                gfx::NativeWindow native_window)
     : profile_(profile),
       ui_loop_(base::MessageLoop::current()),
       extension_(NULL),
       install_ui_(extensions::CreateExtensionInstallUI(profile)),
       show_params_(
           new ExtensionInstallPromptShowParams(profile, native_window)),
-      delegate_(NULL),
       did_call_show_dialog_(false) {
 }
 
 ExtensionInstallPrompt::~ExtensionInstallPrompt() {
 }
 
 void ExtensionInstallPrompt::ShowDialog(
-    Delegate* delegate,
+    const DoneCallback& done_callback,
     const Extension* extension,
     const SkBitmap* icon,
     const ShowDialogCallback& show_dialog_callback) {
-  ShowDialog(delegate, extension, icon,
+  ShowDialog(done_callback, extension, icon,
              make_scoped_ptr(new Prompt(INSTALL_PROMPT)), show_dialog_callback);
 }
 
 void ExtensionInstallPrompt::ShowDialog(
-    Delegate* delegate,
+    const DoneCallback& done_callback,
     const Extension* extension,
     const SkBitmap* icon,
     scoped_ptr<Prompt> prompt,
     const ShowDialogCallback& show_dialog_callback) {
-  ShowDialog(delegate, extension, icon, std::move(prompt), nullptr,
+  ShowDialog(done_callback, extension, icon, std::move(prompt), nullptr,
              show_dialog_callback);
 }
 
 void ExtensionInstallPrompt::ShowDialog(
-    Delegate* delegate,
+    const DoneCallback& done_callback,
     const Extension* extension,
     const SkBitmap* icon,
     scoped_ptr<Prompt> prompt,
     scoped_ptr<const PermissionSet> custom_permissions,
     const ShowDialogCallback& show_dialog_callback) {
   DCHECK(ui_loop_ == base::MessageLoop::current());
   DCHECK(prompt);
   extension_ = extension;
-  delegate_ = delegate;
+  done_callback_ = done_callback;
   if (icon && !icon->empty())
     SetIcon(icon);
   prompt_ = std::move(prompt);
   custom_permissions_ = std::move(custom_permissions);
   show_dialog_callback_ = show_dialog_callback;
 
   // We special-case themes to not show any confirm UI. Instead they are
   // immediately installed, and then we show an infobar (see OnInstallSuccess)
   // to allow the user to revert if they don't like it.
   //
   // We don't do this in the case where off-store extension installs are
   // disabled because in that case, we don't show the dangerous download UI, so
   // we need the UI confirmation.
   if (extension->is_theme()) {
     if (extension->from_webstore() ||
         extensions::FeatureSwitch::easy_off_store_install()->IsEnabled()) {
-      delegate->InstallUIProceed();
+      base::ResetAndReturn(&done_callback_).Run(Result::ACCEPTED);
       return;
     }
   }
 
   LoadImageIfNeeded();
 }
 
 void ExtensionInstallPrompt::OnInstallSuccess(const Extension* extension,
                                               SkBitmap* icon) {
   extension_ = extension;
@@ skipping 123 matching lines @@
       break;
     }
     case LAUNCH_PROMPT_DEPRECATED:
     default:
       NOTREACHED() << "Unknown message";
       return;
   }
   prompt_->set_icon(gfx::Image::CreateFrom1xBitmap(icon_));
 
   if (show_params_->WasParentDestroyed()) {
-    delegate_->InstallUIAbort(false);
+    base::ResetAndReturn(&done_callback_).Run(Result::ABORTED);
     return;
   }
 
   g_last_prompt_type_for_tests = prompt_->type();
   did_call_show_dialog_ = true;
 
-  if (AutoConfirmPrompt(delegate_))
+  if (AutoConfirmPrompt(&done_callback_))
     return;
 
   if (show_dialog_callback_.is_null())
-    GetDefaultShowDialogCallback().Run(show_params_.get(), delegate_,
-                                       std::move(prompt_));
-  else
-    show_dialog_callback_.Run(show_params_.get(), delegate_,
-                              std::move(prompt_));
+    show_dialog_callback_ = GetDefaultShowDialogCallback();
+  base::ResetAndReturn(&show_dialog_callback_)
+      .Run(show_params_.get(), base::ResetAndReturn(&done_callback_),
+           std::move(prompt_));
 }