[Extensions] Don't use ExtensionInstallPrompt subclasses for auto-confirmation

chrome/browser/extensions/crx_installer_browsertest.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/crx_installer.h"
 
 #include "base/at_exit.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/web_application_info.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_observer.h"
 #include "content/public/test/test_utils.h"
+#include "extensions/browser/extension_dialog_auto_confirm.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install/crx_install_error.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/feature_switch.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/permissions/api_permission.h"
@@ skipping 23 matching lines @@
 namespace extensions {
 
 namespace {
 
 class MockInstallPrompt;
 
 // This class holds information about things that happen with a
 // MockInstallPrompt. We create the MockInstallPrompt but need to pass
 // ownership of it to CrxInstaller, so it isn't safe to hang this data on
 // MockInstallPrompt itself becuase we can't guarantee it's lifetime.
-class MockPromptProxy : public base::RefCountedThreadSafe<MockPromptProxy> {
+class MockPromptProxy {
  public:
   explicit MockPromptProxy(content::WebContents* web_contents);
+  ~MockPromptProxy();
 
   bool did_succeed() const { return !extension_id_.empty(); }
   const std::string& extension_id() { return extension_id_; }
   bool confirmation_requested() const { return confirmation_requested_; }
   const base::string16& error() const { return error_; }
 
   void set_extension_id(const std::string& id) { extension_id_ = id; }
-  void set_confirmation_requested() { confirmation_requested_ = true; }
+  void set_confirmation_requested(bool requested) {
+    confirmation_requested_ = requested;
+  }
   void set_error(const base::string16& error) { error_ = error; }
 
   scoped_ptr<ExtensionInstallPrompt> CreatePrompt();
 
  private:
-  friend class base::RefCountedThreadSafe<MockPromptProxy>;
-  virtual ~MockPromptProxy();
 
   // Data used to create a prompt.
   content::WebContents* web_contents_;
 
   // Data reported back to us by the prompt we created.
   bool confirmation_requested_;
   std::string extension_id_;
   base::string16 error_;
+
+  scoped_ptr<ScopedTestDialogAutoConfirm> auto_confirm;
+
+  DISALLOW_COPY_AND_ASSIGN(MockPromptProxy);
 };
 
 SkBitmap CreateSquareBitmap(int size) {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(size, size);
   bitmap.eraseColor(SK_ColorRED);
   return bitmap;
 }
 
 WebApplicationInfo::IconInfo CreateIconInfoWithBitmap(int size) {
@@ skipping 19 matching lines @@
 }
 
 class MockInstallPrompt : public ExtensionInstallPrompt {
  public:
   MockInstallPrompt(content::WebContents* web_contents,
                     MockPromptProxy* proxy) :
       ExtensionInstallPrompt(web_contents),
       proxy_(proxy) {}
 
   // Overriding some of the ExtensionInstallUI API.
-  void ShowDialog(Delegate* delegate,
-                  const Extension* extension,
-                  const SkBitmap* bitmap,
-                  const ShowDialogCallback& show_dialog_callback) override {
-    proxy_->set_confirmation_requested();
-    delegate->InstallUIProceed();
-  }
   void OnInstallSuccess(const Extension* extension, SkBitmap* icon) override {
     proxy_->set_extension_id(extension->id());
+    proxy_->set_confirmation_requested(did_call_show_dialog());
     base::MessageLoopForUI::current()->QuitWhenIdle();
   }
   void OnInstallFailure(const CrxInstallError& error) override {
     proxy_->set_error(error.message());
+    proxy_->set_confirmation_requested(did_call_show_dialog());
     base::MessageLoopForUI::current()->QuitWhenIdle();
   }
 
  private:
-  scoped_refptr<MockPromptProxy> proxy_;
+  MockPromptProxy* proxy_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockInstallPrompt);
 };
 
 MockPromptProxy::MockPromptProxy(content::WebContents* web_contents)
-    : web_contents_(web_contents), confirmation_requested_(false) {
+    : web_contents_(web_contents),
+      confirmation_requested_(false),
+      auto_confirm(new ScopedTestDialogAutoConfirm(
+          ScopedTestDialogAutoConfirm::ACCEPT)) {
 }
 
 MockPromptProxy::~MockPromptProxy() {}
 
 scoped_ptr<ExtensionInstallPrompt> MockPromptProxy::CreatePrompt() {
   return scoped_ptr<MockInstallPrompt>(
       new MockInstallPrompt(web_contents_, this));
 }
 
 
-scoped_refptr<MockPromptProxy> CreateMockPromptProxyForBrowser(
+scoped_ptr<MockPromptProxy> CreateMockPromptProxyForBrowser(
     Browser* browser) {
-  return new MockPromptProxy(
-      browser->tab_strip_model()->GetActiveWebContents());
+  return make_scoped_ptr(new MockPromptProxy(
+      browser->tab_strip_model()->GetActiveWebContents()));
 }
 
 class ManagementPolicyMock : public extensions::ManagementPolicy::Provider {
  public:
   ManagementPolicyMock() {}
 
   std::string GetDebugPolicyProviderName() const override {
     return "ManagementPolicyMock";
   }
 
@@ skipping 56 matching lines @@
     installer->set_allow_silent_install(true);
     installer->set_is_gallery_install(true);
     installer->InstallCrx(crx_path);
     content::RunMessageLoop();
   }
 
   // Installs a crx from |crx_relpath| (a path relative to the extension test
   // data dir) with expected id |id|.
   void InstallWithPrompt(const char* ext_relpath,
                          const std::string& id,
-                         scoped_refptr<MockPromptProxy> mock_install_prompt) {
+                         MockPromptProxy* mock_install_prompt) {
     base::FilePath ext_path = test_data_dir_.AppendASCII(ext_relpath);
 
     scoped_ptr<WebstoreInstaller::Approval> approval;
     if (!id.empty())
       approval = GetApproval(ext_relpath, id, true);
 
     base::FilePath crx_path = PackExtension(ext_path);
     EXPECT_FALSE(crx_path.empty());
     RunCrxInstaller(approval.get(), mock_install_prompt->CreatePrompt(),
                     crx_path);
 
     EXPECT_TRUE(mock_install_prompt->did_succeed());
   }
 
   // Installs an extension and checks that it has scopes granted IFF
   // |record_oauth2_grant| is true.
   void CheckHasEmptyScopesAfterInstall(const std::string& ext_relpath,
                                        bool record_oauth2_grant) {
     ScopedExperimentalCommandLine scope;
 
-    scoped_refptr<MockPromptProxy> mock_prompt =
+    scoped_ptr<MockPromptProxy> mock_prompt =
         CreateMockPromptProxyForBrowser(browser());
 
-    InstallWithPrompt("browsertest/scopes", std::string(), mock_prompt);
+    InstallWithPrompt("browsertest/scopes", std::string(), mock_prompt.get());
 
     scoped_ptr<const PermissionSet> permissions =
         ExtensionPrefs::Get(browser()->profile())
             ->GetGrantedPermissions(mock_prompt->extension_id());
     ASSERT_TRUE(permissions.get());
   }
 
   // Returns a FilePath to an unpacked "experimental" extension (a test
   // Extension which requests the "experimental" permission).
   base::FilePath PackExperimentalExtension() {
@@ skipping 32 matching lines @@
 
 // This test is skipped on ChromeOS because it requires the NPAPI,
 // which is not available on that platform.
 #if !defined(OS_CHROMEOS)
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, Whitelisting) {
   std::string id = "hdgllgikmikobbofgnabhfimcfoopgnd";
   ExtensionRegistry* registry = ExtensionRegistry::Get(
       browser()->profile());
 
   // Even whitelisted extensions with NPAPI should not prompt.
-  scoped_refptr<MockPromptProxy> mock_prompt =
+  scoped_ptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
-  InstallWithPrompt("uitest/plugins", id, mock_prompt);
+  InstallWithPrompt("uitest/plugins", id, mock_prompt.get());
   EXPECT_FALSE(mock_prompt->confirmation_requested());
   EXPECT_TRUE(registry->enabled_extensions().GetByID(id));
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest,
                        ExperimentalExtensionFromGallery) {
   // Gallery-installed extensions should have their experimental permission
   // preserved, since we allow the Webstore to make that decision.
   base::FilePath crx_path = PackExperimentalExtension();
@@ skipping 38 matching lines @@
 
   const int kNumDownloadsExpected = 1;
 
   LOG(ERROR) << "PackAndInstallExtension: Packing extension";
   base::FilePath crx_path = PackExtension(
       test_data_dir_.AppendASCII("common/background_page"));
   ASSERT_FALSE(crx_path.empty());
   std::string crx_path_string(crx_path.value().begin(), crx_path.value().end());
   GURL url = GURL(std::string("file:///").append(crx_path_string));
 
-  scoped_refptr<MockPromptProxy> mock_prompt =
+  scoped_ptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
   download_crx_util::SetMockInstallPromptForTesting(
       mock_prompt->CreatePrompt());
 
   LOG(ERROR) << "PackAndInstallExtension: Getting download manager";
   content::DownloadManager* download_manager =
       content::BrowserContext::GetDownloadManager(browser()->profile());
 
   LOG(ERROR) << "PackAndInstallExtension: Setting observer";
   scoped_ptr<content::DownloadTestObserver> observer(
@@ skipping 26 matching lines @@
   EXPECT_NO_FATAL_FAILURE(CheckHasEmptyScopesAfterInstall("browsertest/scopes",
                                                           false));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, AllowOffStore) {
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser()->profile())->extension_service();
   const bool kTestData[] = {false, true};
 
   for (size_t i = 0; i < arraysize(kTestData); ++i) {
-    scoped_refptr<MockPromptProxy> mock_prompt =
+    scoped_ptr<MockPromptProxy> mock_prompt =
         CreateMockPromptProxyForBrowser(browser());
 
     scoped_refptr<CrxInstaller> crx_installer(
         CrxInstaller::Create(service, mock_prompt->CreatePrompt()));
     crx_installer->set_install_cause(
         extension_misc::INSTALL_CAUSE_USER_DOWNLOAD);
 
     if (kTestData[i]) {
       crx_installer->set_off_store_install_allow_reason(
           CrxInstaller::OffStoreInstallAllowedInTest);
@@ skipping 103 matching lines @@
 
   blacklist_db->SetUnsafe("gllekhaobjnhgeagipipnkpmmmpchacm");
 
   base::FilePath crx_path = test_data_dir_.AppendASCII("theme_hidpi_crx")
                                           .AppendASCII("theme_hidpi.crx");
   EXPECT_FALSE(InstallExtension(crx_path, 0));
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(ExtensionCrxInstallerTest, NonStrictManifestCheck) {
-  scoped_refptr<MockPromptProxy> mock_prompt =
+  scoped_ptr<MockPromptProxy> mock_prompt =
       CreateMockPromptProxyForBrowser(browser());
 
   // We want to simulate the case where the webstore sends a more recent
   // version of the manifest, but the downloaded .crx file is old since
   // the newly published version hasn't fully propagated to all the download
   // servers yet. So load the v2 manifest, but then install the v1 crx file.
   std::string id = "lhnaeclnpobnlbjbgogdanmhadigfnjp";
   scoped_ptr<WebstoreInstaller::Approval> approval =
       GetApproval("crx_installer/v2_no_permission_change/", id, false);
 
@@ skipping 86 matching lines @@
   // these checks (see https://crbug.com/545541).
   ManagementPolicyMock policy;
   extensions::ExtensionSystem::Get(profile())
       ->management_policy()
       ->RegisterProvider(&policy);
 
   InstallWebAppAndVerifyNoErrors();
 }
 
 }  // namespace extensions