Preserve Page::openedByDOM state across process swaps.

chrome/browser/prerender/prerender_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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 28 matching lines @@
 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 #include "chrome/browser/safe_browsing/database_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/mime_types_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
@@ skipping 256 matching lines @@
   base::RunLoop loop_;
 };
 
 // Waits for a new tab to open and a navigation or swap in it.
 class NewTabNavigationOrSwapObserver {
  public:
   NewTabNavigationOrSwapObserver()
       : new_tab_observer_(
             chrome::NOTIFICATION_TAB_ADDED,
             base::Bind(&NewTabNavigationOrSwapObserver::OnTabAdded,
-                       base::Unretained(this))) {
+                       base::Unretained(this))),
+        new_tab_(NULL) {
     // Watch for NOTIFICATION_TAB_ADDED. Add a callback so that the
     // NavigationOrSwapObserver can be attached synchronously and no events are
     // missed.
   }
 
+  WebContents* new_tab() const {
+    return new_tab_;
+  }
+
   void Wait() {
     new_tab_observer_.Wait();
     swap_observer_->Wait();
   }
 
   bool OnTabAdded(const content::NotificationSource& source,
                   const content::NotificationDetails& details) {
     if (swap_observer_)
       return true;
-    WebContents* new_tab = content::Details<WebContents>(details).ptr();
+    new_tab_ = content::Details<WebContents>(details).ptr();
     // Get the TabStripModel. Assume this is attached to a Browser.
     TabStripModel* tab_strip_model =
-        static_cast<Browser*>(new_tab->GetDelegate())->tab_strip_model();
+        static_cast<Browser*>(new_tab_->GetDelegate())->tab_strip_model();
     swap_observer_.reset(new NavigationOrSwapObserver(tab_strip_model,
-                                                      new_tab));
+                                                      new_tab_));
     return true;
   }
 
  private:
   content::WindowedNotificationObserver new_tab_observer_;
+  WebContents* new_tab_;
   scoped_ptr<NavigationOrSwapObserver> swap_observer_;
 };
 
 // PrerenderContents that stops the UI message loop on DidStopLoading().
 class TestPrerenderContents : public PrerenderContents {
  public:
   TestPrerenderContents(
       PrerenderManager* prerender_manager,
       Profile* profile,
       const GURL& url,
@@ skipping 787 matching lines @@
   }
 
   void OpenDestURLViaClick() const {
     OpenURLViaClick(dest_url_);
   }
 
   void OpenURLViaClick(const GURL& url) const {
     OpenURLWithJSImpl("Click", url, GURL(), false);
   }
 
-  void OpenDestURLViaClickTarget() const {
-    OpenURLWithJSImpl("ClickTarget", dest_url_, GURL(), true);
+  WebContents* OpenDestURLViaClickTarget() const {
+    return OpenURLWithJSImpl("ClickTarget", dest_url_, GURL(), true);
   }
 
   void OpenDestURLViaClickPing(const GURL& ping_url) const {
     OpenURLWithJSImpl("ClickPing", dest_url_, ping_url, false);
   }
 
-  void OpenDestURLViaClickNewWindow() const {
-    OpenURLWithJSImpl("ShiftClick", dest_url_, GURL(), true);
+  WebContents* OpenDestURLViaClickNewWindow() const {
+    return OpenURLWithJSImpl("ShiftClick", dest_url_, GURL(), true);
   }
 
-  void OpenDestURLViaClickNewForegroundTab() const {
+  WebContents* OpenDestURLViaClickNewForegroundTab() const {
 #if defined(OS_MACOSX)
-    OpenURLWithJSImpl("MetaShiftClick", dest_url_, GURL(), true);
+    return OpenURLWithJSImpl("MetaShiftClick", dest_url_, GURL(), true);
 #else
-    OpenURLWithJSImpl("CtrlShiftClick", dest_url_, GURL(), true);
+    return OpenURLWithJSImpl("CtrlShiftClick", dest_url_, GURL(), true);
 #endif
   }
 
-  void OpenDestURLViaClickNewBackgroundTab() const {
+  WebContents* OpenDestURLViaClickNewBackgroundTab() const {
 #if defined(OS_MACOSX)
-    OpenURLWithJSImpl("MetaClick", dest_url_, GURL(), true);
+    return OpenURLWithJSImpl("MetaClick", dest_url_, GURL(), true);
 #else
-    OpenURLWithJSImpl("CtrlClick", dest_url_, GURL(), true);
+    return OpenURLWithJSImpl("CtrlClick", dest_url_, GURL(), true);
 #endif
   }
 
-  void OpenDestURLViaWindowOpen() const {
-    OpenURLWithJSImpl("WindowOpen", dest_url_, GURL(), true);
+  WebContents* OpenDestURLViaWindowOpen() const {
+    return OpenURLViaWindowOpen(dest_url_);
+  }
+
+  WebContents* OpenURLViaWindowOpen(const GURL& url) const {
+    return OpenURLWithJSImpl("WindowOpen", url, GURL(), true);
   }
 
   void RemoveLinkElement(int i) const {
     GetActiveWebContents()->GetMainFrame()->ExecuteJavaScript(
         base::ASCIIToUTF16(base::StringPrintf("RemoveLinkElement(%d)", i)));
   }
 
   void ClickToNextPageAfterPrerender() {
     TestNavigationObserver nav_observer(GetActiveWebContents());
     RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
@@ skipping 375 matching lines @@
 
     if (web_contents && expect_swap_to_succeed) {
       EXPECT_EQ(web_contents, target_web_contents);
       if (call_javascript_)
         EXPECT_TRUE(DidDisplayPass(web_contents));
     }
   }
 
   // Opens the prerendered page using javascript functions in the loader
   // page. |javascript_function_name| should be a 0 argument function which is
-  // invoked. |new_web_contents| is true if the navigation is expected to
-  // happen in a new WebContents via OpenURL.
-  void OpenURLWithJSImpl(const std::string& javascript_function_name,
-                         const GURL& url,
-                         const GURL& ping_url,
-                         bool new_web_contents) const {
+  // invoked. |new_web_contents| is true if the navigation is expected to happen
+  // in a new WebContents via OpenURL and the new WebContents is returned.
+  WebContents* OpenURLWithJSImpl(const std::string& javascript_function_name,
+                                 const GURL& url,
+                                 const GURL& ping_url,
+                                 bool new_web_contents) const {
     WebContents* web_contents = GetActiveWebContents();
     RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
     // Extra arguments in JS are ignored.
     std::string javascript = base::StringPrintf(
         "%s('%s', '%s')", javascript_function_name.c_str(),
         url.spec().c_str(), ping_url.spec().c_str());
 
     if (new_web_contents) {
       NewTabNavigationOrSwapObserver observer;
       render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
       observer.Wait();
+      return observer.new_tab();
     } else {
       NavigationOrSwapObserver observer(current_browser()->tab_strip_model(),
                                         web_contents);
       render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
       observer.Wait();
+      return NULL;
     }
   }
 
   TestPrerenderContentsFactory* prerender_contents_factory_;
 #if defined(FULL_SAFE_BROWSING)
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
 #endif
   NeverRunsExternalProtocolHandlerDelegate external_protocol_handler_delegate_;
   GURL dest_url_;
   scoped_ptr<net::SpawnedTestServer> https_src_server_;
@@ skipping 1247 matching lines @@
 // and both pages are in the same domain the prerendered page is not used, due
 // to window.opener.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSameDomainWindowOpenerClickTarget) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_WINDOW_OPENER,
                    1);
   OpenDestURLViaClickTarget();
 }
 
+// Checks that, if a popup's opener is closed, it still will not accept
+// prerender swaps. This is relevant in determining whether window.close() may
+// be called.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderOpenerClosed) {
+  // Bump the abandon timeout to ensure the prerender survives its referrer
+  // closing.
+  GetPrerenderManager()->mutable_config().abandon_time_to_live =
+      base::TimeDelta::FromMinutes(5);
+
+  PrerenderTestURL("files/prerender/prerender_page.html",
+                   FINAL_STATUS_WINDOW_OPENER,
+                   1);
+
+  // Open a popup with the referring page as opener.
+  WebContents* opener = GetActiveWebContents();
+  WebContents* popup = OpenURLViaWindowOpen(GURL(content::kAboutBlankURL));
+
+  // Close the opener. The opener is gone, but WasOpenedByDOM() remains true.
+  EXPECT_TRUE(popup->HasOpener());
+  EXPECT_TRUE(popup->CreatedWithOpener());
+  chrome::CloseWebContents(browser(), opener, false);
+  EXPECT_FALSE(popup->HasOpener());
+  EXPECT_TRUE(popup->CreatedWithOpener());
+
+  // Assume the popup is attached to a Browser.
+  set_browser(static_cast<Browser*>(popup->GetDelegate()));
+
+  // The prerender should not swap.
+  NavigateToURLWithDisposition(dest_url(), CURRENT_TAB, false);
+}
+
 class TestClientCertStore : public net::ClientCertStore {
  public:
   TestClientCertStore() {}
   virtual ~TestClientCertStore() {}
 
   // net::ClientCertStore:
   virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
                               net::CertificateList* selected_certs,
                               const base::Closure& callback) OVERRIDE {
     *selected_certs = net::CertificateList(
@@ skipping 1291 matching lines @@
   }
 };
 
 // Checks that prerendering works in incognito mode.
 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender