Changes to not use the prerendered contents when window.opener needs to be set.

chrome/browser/prerender/prerender_browsertest.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
@@ skipping 35 matching lines @@
 std::string CreateClientRedirect(const std::string& dest_url) {
   const char* const kClientRedirectBase = "client-redirect?";
   return kClientRedirectBase + dest_url;
 }
 
 std::string CreateServerRedirect(const std::string& dest_url) {
   const char* const kServerRedirectBase = "server-redirect?";
   return kServerRedirectBase + dest_url;
 }
 
+// Returns true iff the final status is one in which the prerendered

[dominich, 2011/05/16 22:21:12]

nit: 'if'

+// page should prerender correctly. The page still may not be used.
+bool ShouldRenderPrerenderedPageCorrectly(FinalStatus status) {
+  switch (status) {
+    case FINAL_STATUS_USED:
+    case FINAL_STATUS_WINDOW_OPENER:
+      return true;
+    default:
+      return false;
+  }
+}
+
 // PrerenderContents that stops the UI message loop on DidStopLoading().
 class TestPrerenderContents : public PrerenderContents {
  public:
   TestPrerenderContents(
       PrerenderManager* prerender_manager,
       Profile* profile,
       const GURL& url,
       const GURL& referrer,
       int number_of_loads,
       FinalStatus expected_final_status)
@@ skipping 23 matching lines @@
     if (final_status() == FINAL_STATUS_USED) {
       EXPECT_TRUE(new_render_view_host_);
       EXPECT_TRUE(was_shown_);
     } else {
       EXPECT_FALSE(was_shown_);
     }
 
     // When the PrerenderContents is destroyed, quit the UI message loop.
     // This happens on navigation to used prerendered pages, and soon
     // after cancellation of unused prerendered pages.
+    MessageLoopForUI::current()->RunAllPending();
     MessageLoopForUI::current()->Quit();
   }
 
   virtual void OnRenderViewGone(int status, int exit_code) OVERRIDE {
     // On quit, it's possible to end up here when render processes are closed
     // before the PrerenderManager is destroyed.  As a result, it's possible to
     // get either FINAL_STATUS_APP_TERMINATING or FINAL_STATUS_RENDERER_CRASHED
     // on quit.
     if (expected_final_status_ == FINAL_STATUS_APP_TERMINATING)
       expected_final_status_ = FINAL_STATUS_RENDERER_CRASHED;
 
     PrerenderContents::OnRenderViewGone(status, exit_code);
   }
 
   virtual void DidStopLoading() OVERRIDE {
     PrerenderContents::DidStopLoading();
     ++number_of_loads_;
-    if (expected_final_status_ == FINAL_STATUS_USED &&
+    if (ShouldRenderPrerenderedPageCorrectly(expected_final_status_) &&
         number_of_loads_ >= expected_number_of_loads_) {
       MessageLoopForUI::current()->Quit();
     } else if (expected_final_status_ == FINAL_STATUS_RENDERER_CRASHED) {
       // Crash the render process.  This has to be done here because
       // a prerender navigating to about:crash is cancelled with
       // "FINAL_STATUS_HTTPS".  Even if this were worked around,
       // about:crash can't be navigated to by a normal webpage.
       render_view_host_mutable()->NavigateToURL(GURL("about:crash"));
     }
   }
@@ skipping 150 matching lines @@
     ASSERT_TRUE(test_server()->Start());
     std::deque<FinalStatus> expected_final_status_queue(1,
                                                         expected_final_status);
     PrerenderTestURLImpl(url, expected_final_status_queue, total_navigations);
   }
 
   void NavigateToDestURL() const {
     NavigateToURLImpl(dest_url_);
   }
 
+  void OpenDestUrlInNewWindowViaJs() const {
+    // Make sure in navigating we have a URL to use in the PrerenderManager.
+    EXPECT_TRUE(prerender_manager()->FindEntry(dest_url_) != NULL);
+
+    bool open_window_result = false;
+    ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        browser()->GetSelectedTabContents()->render_view_host(), L"",
+        L"window.domAutomationController.send(JsOpenLinkInNewWindow())",
+        &open_window_result));
+    EXPECT_TRUE(open_window_result);
+  }
+
+  void OpenDestUrlInNewWindowViaClick() const {
+    // Make sure in navigating we have a URL to use in the PrerenderManager.
+    EXPECT_TRUE(prerender_manager()->FindEntry(dest_url_) != NULL);
+
+    bool click_prerendered_link_result = false;
+    ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        browser()->GetSelectedTabContents()->render_view_host(), L"",
+        L"window.domAutomationController.send(ClickOpenLinkInNewWindow())",
+        &click_prerendered_link_result));
+    EXPECT_TRUE(click_prerendered_link_result);
+  }
+
   // Should be const but test_server()->GetURL(...) is not const.
   void NavigateToURL(const std::string& dest_html_file) {
     GURL dest_url = test_server()->GetURL(dest_html_file);
     NavigateToURLImpl(dest_url);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) {
     GURL dest_url = test_server()->GetURL(html_file);
     return (prerender_manager()->FindEntry(dest_url) != NULL);
   }
@@ skipping 70 matching lines @@
     // handle browser navigation directly.
     browser()->OpenURL(src_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
 
     TestPrerenderContents* prerender_contents = NULL;
     ui_test_utils::RunMessageLoop();
 
     prerender_contents =
         static_cast<TestPrerenderContents*>(
             prerender_manager()->FindEntry(dest_url_));
 
-    switch (expected_final_status) {
-      case FINAL_STATUS_USED: {
-        ASSERT_TRUE(prerender_contents != NULL);
+    if (ShouldRenderPrerenderedPageCorrectly(expected_final_status)) {
+      ASSERT_TRUE(prerender_contents != NULL);
+      EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
 
-        if (call_javascript_) {
-          // Check if page behaves as expected while in prerendered state.
-          bool prerender_test_result = false;
-          ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-              prerender_contents->render_view_host_mutable(), L"",
-              L"window.domAutomationController.send(DidPrerenderPass())",
-              &prerender_test_result));
-          EXPECT_TRUE(prerender_test_result);
-        }
-        break;
+      if (call_javascript_) {
+        // Check if page behaves as expected while in prerendered state.
+        bool prerender_test_result = false;
+        ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+            prerender_contents->render_view_host_mutable(), L"",
+            L"window.domAutomationController.send(DidPrerenderPass())",
+            &prerender_test_result));
+        EXPECT_TRUE(prerender_test_result);
       }
-      default:
-        // In the failure case, we should have removed dest_url_ from the
-        // prerender_manager.
-        EXPECT_TRUE(prerender_contents == NULL);
-        break;
+    } else {
+      // In the failure case, we should have removed dest_url_ from the
+      // prerender_manager.
+      EXPECT_TRUE(prerender_contents == NULL);
     }
   }
 
   void NavigateToURLImpl(const GURL& dest_url) const {
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     EXPECT_TRUE(prerender_manager()->FindEntry(dest_url_) != NULL);
 
     // ui_test_utils::NavigateToURL waits until DidStopLoading is called on
     // the current tab.  As that tab is going to end up deleted, and may never
     // finish loading before that happens, exit the message loop on the deletion
@@ skipping 660 matching lines @@
       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
+// Checks that if a page is opened in a new window by javascript the
+// prerendered page is not used.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       PrerenderWindowOpenerJsOpenInNewPageTest) {
+  PrerenderTestURL("files/prerender/prerender_page.html",
+                   FINAL_STATUS_WINDOW_OPENER,
+                   1);
+  OpenDestUrlInNewWindowViaJs();
+}
+
+// Checks that if a page is opened due to click on a href with target="_blank"
+// the prerendered page is not used.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       PrerenderWindowOpenerClickOpenInNewPageTest) {
+  PrerenderTestURL("files/prerender/prerender_page.html",
+                   FINAL_STATUS_WINDOW_OPENER,
+                   1);
+  OpenDestUrlInNewWindowViaClick();
+}
+
+// TODO(shishir): Add a test for the case when the page having the
+// prerendering link already has an opener set.
+
 }  // namespace prerender