Make ExtensionInstallPrompt::Prompt ref-counted

chrome/browser/extensions/external_install_ui.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_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 83 matching lines @@
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Show the install dialog to the user.
   void ShowInstallUI();
 
   // The UI for showing the install dialog when enabling.
   scoped_ptr<ExtensionInstallPrompt> install_ui_;
-  scoped_ptr<ExtensionInstallPrompt::Prompt> prompt_;
+  scoped_refptr<ExtensionInstallPrompt::Prompt> prompt_;
 
   Browser* browser_;
   base::WeakPtr<ExtensionService> service_weak_;
   scoped_ptr<WebstoreDataFetcher> webstore_data_fetcher_;
   content::NotificationRegistrar registrar_;
   std::string extension_id_;
   bool use_global_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalInstallDialogDelegate);
 };
@@ skipping 45 matching lines @@
   // Listen to extension load notifications.
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalInstallMenuAlert);
 };
 
 // Shows a menu item and a global error bubble, replacing the install dialog.
 class ExternalInstallGlobalError : public ExternalInstallMenuAlert {
  public:
-  ExternalInstallGlobalError(ExtensionService* service,
-                             const Extension* extension,
-                             ExternalInstallDialogDelegate* delegate,
-                             const ExtensionInstallPrompt::Prompt& prompt);
+  ExternalInstallGlobalError(
+      ExtensionService* service,
+      const Extension* extension,
+      ExternalInstallDialogDelegate* delegate,
+      scoped_refptr<ExtensionInstallPrompt::Prompt> prompt);
   virtual ~ExternalInstallGlobalError();
 
   virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
   virtual bool HasBubbleView() OVERRIDE;
   virtual gfx::Image GetBubbleViewIcon() OVERRIDE;
   virtual base::string16 GetBubbleViewTitle() OVERRIDE;
   virtual std::vector<base::string16> GetBubbleViewMessages() OVERRIDE;
   virtual base::string16 GetBubbleViewAcceptButtonLabel() OVERRIDE;
   virtual base::string16 GetBubbleViewCancelButtonLabel() OVERRIDE;
   virtual void OnBubbleViewDidClose(Browser* browser) OVERRIDE;
   virtual void BubbleViewAcceptButtonPressed(Browser* browser) OVERRIDE;
   virtual void BubbleViewCancelButtonPressed(Browser* browser) OVERRIDE;
 
  protected:
   // Ref-counted, but needs to be disposed of if we are dismissed without
   // having been clicked (perhaps because the user enabled the extension
   // manually).
   ExternalInstallDialogDelegate* delegate_;
-  const ExtensionInstallPrompt::Prompt* prompt_;
+  scoped_refptr<ExtensionInstallPrompt::Prompt> prompt_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExternalInstallGlobalError);
 };
 
 static void CreateExternalInstallGlobalError(
     base::WeakPtr<ExtensionService> service,
     const std::string& extension_id,
     const ExtensionInstallPrompt::ShowParams& show_params,
     ExtensionInstallPrompt::Delegate* prompt_delegate,
-    const ExtensionInstallPrompt::Prompt& prompt) {
+    scoped_refptr<ExtensionInstallPrompt::Prompt> prompt) {
   if (!service.get())
     return;
   const Extension* extension = service->GetInstalledExtension(extension_id);
   if (!extension)
     return;
   GlobalErrorService* error_service =
       GlobalErrorServiceFactory::GetForProfile(service->profile());
   if (error_service->GetGlobalErrorByMenuItemCommandID(kMenuCommandId))
     return;
 
@@ skipping 21 matching lines @@
     Browser* browser,
     ExtensionService* service,
     const Extension* extension,
     bool use_global_error)
     : browser_(browser),
       service_weak_(service->AsWeakPtr()),
       extension_id_(extension->id()),
       use_global_error_(use_global_error) {
   AddRef();  // Balanced in Proceed or Abort.
 
-  prompt_.reset(new ExtensionInstallPrompt::Prompt(
-      ExtensionInstallPrompt::EXTERNAL_INSTALL_PROMPT));
+  prompt_ = new ExtensionInstallPrompt::Prompt(
+      ExtensionInstallPrompt::EXTERNAL_INSTALL_PROMPT);
 
   // If we don't have a browser, we can't go to the webstore to fetch data.
   // This should only happen in tests.
   if (!browser) {
     ShowInstallUI();
     return;
   }
 
   // Make sure to be notified if the owning profile is destroyed.
   registrar_.Add(this,
@@ skipping 60 matching lines @@
   install_ui_.reset(
       ExtensionInstallUI::CreateInstallPromptWithBrowser(browser_));
 
   const ExtensionInstallPrompt::ShowDialogCallback callback =
       use_global_error_ ?
           base::Bind(&CreateExternalInstallGlobalError,
                      service_weak_,
                      extension_id_) :
           ExtensionInstallPrompt::GetDefaultShowDialogCallback();
 
-  install_ui_->ConfirmExternalInstall(this, extension, callback, *prompt_);
+  install_ui_->ConfirmExternalInstall(this, extension, callback, prompt_);
 }
 
 ExternalInstallDialogDelegate::~ExternalInstallDialogDelegate() {
 }
 
 void ExternalInstallDialogDelegate::InstallUIProceed() {
   const Extension* extension = NULL;
   if (service_weak_.get() &&
       (extension = service_weak_->GetInstalledExtension(extension_id_))) {
     service_weak_->GrantPermissionsAndEnableExtension(extension);
@@ skipping 116 matching lines @@
   service_->AcknowledgeExternalExtension(extension_->id());
   delete this;
 }
 
 // ExternalInstallGlobalError -----------------------------------------------
 
 ExternalInstallGlobalError::ExternalInstallGlobalError(
     ExtensionService* service,
     const Extension* extension,
     ExternalInstallDialogDelegate* delegate,
-    const ExtensionInstallPrompt::Prompt& prompt)
+    scoped_refptr<ExtensionInstallPrompt::Prompt> prompt)
     : ExternalInstallMenuAlert(service, extension),
       delegate_(delegate),
-      prompt_(&prompt) {
+      prompt_(prompt) {
 }
 
 ExternalInstallGlobalError::~ExternalInstallGlobalError() {
   if (delegate_)
     delegate_->Release();
 }
 
 void ExternalInstallGlobalError::ExecuteMenuItem(Browser* browser) {
   ShowBubbleView(browser);
 }
@@ skipping 103 matching lines @@
 
 bool HasExternalInstallBubble(ExtensionService* service) {
   GlobalErrorService* error_service =
       GlobalErrorServiceFactory::GetForProfile(service->profile());
   GlobalError* error = error_service->GetGlobalErrorByMenuItemCommandID(
       kMenuCommandId);
   return error && error->HasBubbleView();
 }
 
 }  // namespace extensions