Prerendered pages are swapped in at browser::Navigate time.

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 "base/command_line.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
@@ skipping 152 matching lines @@
     // TabContents, at the end of a navigation caused by a call to
     // NavigateToURLImpl().
     if (final_status() == FINAL_STATUS_USED)
       EXPECT_TRUE(new_render_view_host_);
 
     EXPECT_EQ(should_be_shown_, 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.
-    if (quit_message_loop_on_destruction_)
-      MessageLoopForUI::current()->Quit();
+    if (quit_message_loop_on_destruction_) {
+      // The message loop may not be running if this is swapped in
+      // synchronously on a Navigation.
+      MessageLoop* loop = MessageLoopForUI::current();
+      if (loop->is_running())
+        loop->Quit();
+    }
   }
 
   virtual void RenderViewGone(base::TerminationStatus status) 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.
     //
     // It's also possible for this to be called after we've been notified of
     // app termination, but before we've been deleted, which is why the second
@@ skipping 294 matching lines @@
                                                         expected_final_status);
     PrerenderTestURL(html_file,
                      expected_final_status_queue,
                      expected_number_of_loads);
   }
 
   void PrerenderTestURL(
       const std::string& html_file,
       const std::deque<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
-    PrerenderTestURLImpl(test_server()->GetURL(html_file),
+    GURL url = test_server()->GetURL(html_file);
+    PrerenderTestURLImpl(url, url,
                          expected_final_status_queue,
                          expected_number_of_loads);
   }
 
   void PrerenderTestURL(
       const GURL& url,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
     std::deque<FinalStatus> expected_final_status_queue(1,
                                                         expected_final_status);
-    PrerenderTestURLImpl(url,
+    PrerenderTestURLImpl(url, url,
                          expected_final_status_queue,
                          expected_number_of_loads);
   }
+
+  void PrerenderTestURL(
+      const GURL& prerender_url,
+      const GURL& destination_url,
+      FinalStatus expected_final_status,
+      int expected_number_of_loads) {
+    std::deque<FinalStatus> expected_final_status_queue(1,
+                                                        expected_final_status);
+    PrerenderTestURLImpl(prerender_url, destination_url,
+                         expected_final_status_queue,
+                         expected_number_of_loads);
+  }
 
   void NavigateToDestURL() const {
     NavigateToDestURLWithDisposition(CURRENT_TAB);
   }
 
   // Opens the url in a new tab, with no opener.
   void NavigateToDestURLWithDisposition(
       WindowOpenDisposition disposition) const {
     NavigateToURLImpl(dest_url_, disposition);
   }
@@ skipping 168 matching lines @@
     std::string url_str(base::StringPrintf(
         "http://%s:%d/%s",
         secondary_domain.c_str(),
         test_server()->host_port_pair().port(),
         path.c_str()));
     return GURL(url_str);
   }
 
  private:
   void PrerenderTestURLImpl(
-      const GURL& url,
+      const GURL& prerender_url,
+      const GURL& destination_url,
       const std::deque<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
-    dest_url_ = url;
+    // TODO(cbentzel): Remove dest_url_?
+    dest_url_ = destination_url;
 
     std::vector<net::TestServer::StringPair> replacement_text;
     replacement_text.push_back(
-        make_pair("REPLACE_WITH_PRERENDER_URL", dest_url_.spec()));
+        make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
+    replacement_text.push_back(
+        make_pair("REPLACE_WITH_DESTINATION_URL", destination_url.spec()));
     std::string replacement_path;
     ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
         loader_path_,
         replacement_text,
         &replacement_path));
 
     net::TestServer* src_server = test_server();
     scoped_ptr<net::TestServer> https_src_server;
     if (use_https_src_server_) {
       https_src_server.reset(
@@ skipping 70 matching lines @@
           GetPrerenderContents()->prerender_contents()->web_contents();
       if (GetPrerenderContents()->number_of_loads() == 0) {
         page_load_observer.reset(
             new ui_test_utils::WindowedNotificationObserver(
                 content::NOTIFICATION_LOAD_STOP,
                 content::Source<NavigationController>(
                     &web_contents->GetController())));
       }
     }
 
-    // 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
-    // of the used prerender contents instead.
-    //
-    // As PrerenderTestURL waits until the prerendered page has completely
-    // loaded, there is no race between loading |dest_url| and swapping the
-    // prerendered TabContents into the tab.
+    // Navigate to the prerendered URL, but don't run the message loop. Browser
+    // issued navigations to prerendered pages will synchronously swap in the
+    // prerendered page.
     ui_test_utils::NavigateToURLWithDisposition(
         browser(), dest_url, disposition, ui_test_utils::BROWSER_TEST_NONE);
-    ui_test_utils::RunMessageLoop();
 
     // Make sure the PrerenderContents found earlier was used or removed.
     EXPECT_TRUE(GetPrerenderContents() == NULL);
 
     if (call_javascript_ && web_contents) {
       if (page_load_observer.get())
         page_load_observer->Wait();
 
       bool display_test_result = false;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
@@ skipping 148 matching lines @@
 // This version navigates to the final destination page, rather than the
 // page which does the redirection.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectNavigateToSecond) {
   PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
                    FINAL_STATUS_USED,
                    2);
   NavigateToURL("files/prerender/prerender_page.html");
 }
 
+// Checks that client-issued redirects work with prerendering.
+// This version navigates to the final destination page, rather than the
+// page which does the redirection via a mouse click.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       PrerenderClientRedirectNavigateToSecondViaClick) {
+  GURL prerender_url = test_server()->GetURL(
+      CreateClientRedirect("files/prerender/prerender_page.html"));
+  GURL destination_url = test_server()->GetURL(
+      "files/prerender/prerender_page.html");
+  PrerenderTestURL(prerender_url, destination_url, FINAL_STATUS_USED, 2);
+  OpenDestURLViaClick();
+}
+
 // Checks that a prerender for an https will prevent a prerender from happening.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttps) {
   net::TestServer https_server(net::TestServer::TYPE_HTTPS,
                                net::TestServer::kLocalhost,
                                FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(https_url,
                    FINAL_STATUS_USED,
                    1);
@@ skipping 71 matching lines @@
 // This version navigates to the final destination page, rather than the
 // page which does the redirection.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectNavigateToSecond) {
   PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
                    FINAL_STATUS_USED,
                    1);
   NavigateToURL("files/prerender/prerender_page.html");
 }
 
+// Checks that server-issued redirects work with prerendering.
+// This version navigates to the final destination page, rather than the
+// page which does the redirection via a mouse click.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       PrerenderServerRedirectNavigateToSecondViaClick) {
+  GURL prerender_url = test_server()->GetURL(
+      CreateServerRedirect("files/prerender/prerender_page.html"));
+  GURL destination_url = test_server()->GetURL(
+      "files/prerender/prerender_page.html");
+  PrerenderTestURL(prerender_url, destination_url, FINAL_STATUS_USED, 1);
+  OpenDestURLViaClick();
+}
+
 // Checks that server-issued redirects from an http to an https
 // location will cancel prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectToHttps) {
   net::TestServer https_server(net::TestServer::TYPE_HTTPS,
                                net::TestServer::kLocalhost,
                                FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
   PrerenderTestURL(CreateServerRedirect(https_url.spec()),
@@ skipping 876 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MatchCompleteDummy) {
   std::deque<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_JAVASCRIPT_ALERT);
   expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
   PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
                    expected_final_status_queue, 1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender