Don't allow inline install if frame is deleted before user accepts

chrome/browser/extensions/webstore_inline_installer_browsertest.cc

 // Copyright 2013 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 "base/strings/utf_string_conversions.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/extensions/webstore_inline_installer.h"
 #include "chrome/browser/extensions/webstore_inline_installer_factory.h"
 #include "chrome/browser/extensions/webstore_installer_test.h"
 #include "chrome/browser/extensions/webstore_standalone_installer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/test/browser_test_utils.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "url/gurl.h"
 
 using content::WebContents;
 
 namespace extensions {
 
 namespace {
 
 const char kWebstoreDomain[] = "cws.com";
 const char kAppDomain[] = "app.com";
 const char kNonAppDomain[] = "nonapp.com";
 const char kTestExtensionId[] = "ecglahbcnmdpdciemllbhojghbkagdje";
 const char kTestDataPath[] = "extensions/api_test/webstore_inline_install";
 const char kCrxFilename[] = "extension.crx";
 
+// A struct for letting us store the actual parameters that were passed to
+// the install callback.
+struct InstallResult {
+  bool success = false;
+  std::string error;
+  webstore_install::Result result = webstore_install::RESULT_LAST;
+};
+
 }  // namespace
 
 class WebstoreInlineInstallerTest : public WebstoreInstallerTest {
  public:
   WebstoreInlineInstallerTest()
       : WebstoreInstallerTest(
             kWebstoreDomain,
             kTestDataPath,
             kCrxFilename,
             kAppDomain,
@@ skipping 32 matching lines @@
   static Delegate* delegate_;
 };
 
 ExtensionInstallPrompt::Delegate* ProgrammableInstallPrompt::delegate_;
 
 // Fake inline installer which creates a programmable prompt in place of
 // the normal dialog UI.
 class WebstoreInlineInstallerForTest : public WebstoreInlineInstaller {
  public:
   WebstoreInlineInstallerForTest(WebContents* contents,
+                                 content::RenderFrameHost* host,
                                  const std::string& extension_id,
                                  const GURL& requestor_url,
                                  const Callback& callback)
       : WebstoreInlineInstaller(
             contents,
+            host,
             kTestExtensionId,
             requestor_url,
-            base::Bind(DummyCallback)),
-        programmable_prompt_(NULL) {
-  }
+            base::Bind(&WebstoreInlineInstallerForTest::InstallCallback,
+                       base::Unretained(this))),
+        install_result_target_(nullptr),
+        programmable_prompt_(nullptr) {}
 
   scoped_ptr<ExtensionInstallPrompt> CreateInstallUI() override {
     programmable_prompt_ = new ProgrammableInstallPrompt(web_contents());
     return make_scoped_ptr(programmable_prompt_);
   }
 
+  // Added here to make it public so that test cases can call it below.
+  bool CheckRequestorAlive() const override {
+    return WebstoreInlineInstaller::CheckRequestorAlive();
+  }
+
+  // Tests that care about the actual arguments to the install callback can use
+  // this to receive a copy in |install_result_target|.
+  void set_install_result_target(
+      scoped_ptr<InstallResult>* install_result_target) {
+    install_result_target_ = install_result_target;
+  }
+
  private:
   ~WebstoreInlineInstallerForTest() override {}
 
   friend class base::RefCountedThreadSafe<WebstoreStandaloneInstaller>;
 
-  static void DummyCallback(bool success,
-                            const std::string& error,
-                            webstore_install::Result result) {
+  void InstallCallback(bool success,
+                       const std::string& error,
+                       webstore_install::Result result) {
+    if (install_result_target_) {
+      install_result_target_->reset(new InstallResult);
+      (*install_result_target_)->success = success;
+      (*install_result_target_)->error = error;
+      (*install_result_target_)->result = result;
+    }
   }
 
+  // This can be set by tests that want to get the actual install callback
+  // arguments.
+  scoped_ptr<InstallResult>* install_result_target_;
+
   ProgrammableInstallPrompt* programmable_prompt_;
 };
 
 class WebstoreInlineInstallerForTestFactory :
     public WebstoreInlineInstallerFactory {
+ public:
+  WebstoreInlineInstallerForTestFactory() : last_installer_(nullptr) {}
   ~WebstoreInlineInstallerForTestFactory() override {}
+
+  WebstoreInlineInstallerForTest* last_installer() { return last_installer_; }
+
   WebstoreInlineInstaller* CreateInstaller(
       WebContents* contents,
+      content::RenderFrameHost* host,
       const std::string& webstore_item_id,
       const GURL& requestor_url,
       const WebstoreStandaloneInstaller::Callback& callback) override {
-    return new WebstoreInlineInstallerForTest(
-        contents, webstore_item_id, requestor_url, callback);
+    last_installer_ = new WebstoreInlineInstallerForTest(
+        contents, host, webstore_item_id, requestor_url, callback);
+    return last_installer_;
   }
+
+ private:
+  // The last installer that was created.
+  WebstoreInlineInstallerForTest* last_installer_;
 };
 
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerTest,
                        CloseTabBeforeInstallConfirmation) {
   GURL install_url = GenerateTestServerUrl(kAppDomain, "install.html");
   ui_test_utils::NavigateToURL(browser(), install_url);
   WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   TabHelper* tab_helper = TabHelper::FromWebContents(web_contents);
   tab_helper->SetWebstoreInlineInstallerFactoryForTests(
       new WebstoreInlineInstallerForTestFactory());
   RunTestAsync("runTest");
   while (!ProgrammableInstallPrompt::Ready())
     base::RunLoop().RunUntilIdle();
   web_contents->Close();
   ProgrammableInstallPrompt::Accept();
 }
 
+IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerTest,
+                       NavigateBeforeInstallConfirmation) {
+  GURL install_url = GenerateTestServerUrl(kAppDomain, "install.html");
+  ui_test_utils::NavigateToURL(browser(), install_url);
+  WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  TabHelper* tab_helper = TabHelper::FromWebContents(web_contents);
+  WebstoreInlineInstallerForTestFactory* factory =
+      new WebstoreInlineInstallerForTestFactory();
+  tab_helper->SetWebstoreInlineInstallerFactoryForTests(factory);
+  RunTestAsync("runTest");
+  while (!ProgrammableInstallPrompt::Ready())
+    base::RunLoop().RunUntilIdle();
+  GURL new_url = GenerateTestServerUrl(kNonAppDomain, "empty.html");
+  web_contents->GetController().LoadURL(
+      new_url, content::Referrer(), ui::PAGE_TRANSITION_LINK, std::string());
+  EXPECT_TRUE(content::WaitForLoadStop(web_contents));
+  ASSERT_NE(factory->last_installer(), nullptr);
+  EXPECT_NE(factory->last_installer()->web_contents(), nullptr);
+  EXPECT_FALSE(factory->last_installer()->CheckRequestorAlive());
+
+  // Right now the way we handle navigations away from the frame that began the
+  // inline install is to just declare the requestor to be dead, but not to
+  // kill the prompt (that would be a better UX, but more complicated to
+  // implement). If we ever do change things to kill the prompt in this case,
+  // the following code can be removed (it verifies that clicking ok on the
+  // dialog does not result in an install).
+  scoped_ptr<InstallResult> install_result;
+  factory->last_installer()->set_install_result_target(&install_result);
+  ASSERT_TRUE(ProgrammableInstallPrompt::Ready());
+  ProgrammableInstallPrompt::Accept();
+  ASSERT_NE(install_result.get(), nullptr);
+  EXPECT_EQ(install_result->success, false);
+  EXPECT_EQ(install_result->result, webstore_install::ABORTED);
+}
+
 // Flaky: https://crbug.com/537526.
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerTest,
                        DISABLED_ShouldBlockInlineInstallFromPopupWindow) {
   GURL install_url =
       GenerateTestServerUrl(kAppDomain, "install_from_popup.html");
   // Disable popup blocking for the test url.
   HostContentSettingsMapFactory::GetForProfile(browser()->profile())
       ->SetContentSetting(ContentSettingsPattern::FromURL(install_url),
                           ContentSettingsPattern::Wildcard(),
                           CONTENT_SETTINGS_TYPE_POPUPS,
@@ skipping 84 matching lines @@
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerListenerTest,
                        DownloadProgressListenerTest) {
   RunTest("download_progress_listener.html");
 }
 
 IN_PROC_BROWSER_TEST_F(WebstoreInlineInstallerListenerTest, BothListenersTest) {
   RunTest("both_listeners.html");
 }
 
 }  // namespace extensions