Refactor prerender_browsertests.

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 139 matching lines @@
     case FINAL_STATUS_DEVTOOLS_ATTACHED:
     case FINAL_STATUS_PAGE_BEING_CAPTURED:
     case FINAL_STATUS_NAVIGATION_UNCOMMITTED:
     case FINAL_STATUS_WOULD_HAVE_BEEN_USED:
       return false;
     default:
       return true;
   }
 }
 
+// Convenience function to wait for a title. Handles the case when the
+// WebContents already has the expected title.
+void WaitForASCIITitle(WebContents* web_contents,
+                       const char* expected_title_ascii) {
+  base::string16 expected_title = base::ASCIIToUTF16(expected_title_ascii);
+  if (web_contents->GetTitle() == expected_title)
+    return;
+  content::TitleWatcher title_watcher(web_contents, expected_title);
+  EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
+}
+
 // Waits for the destruction of a RenderProcessHost's IPC channel.
 // Used to make sure the PrerenderLinkManager's OnChannelClosed function has
 // been called, before checking its state.
 class ChannelDestructionWatcher {
  public:
   ChannelDestructionWatcher() : channel_destroyed_(false) {
   }
 
   ~ChannelDestructionWatcher() {
   }
@@ skipping 199 matching lines @@
 
   virtual void AddPendingPrerender(
       scoped_ptr<PendingPrerenderInfo> pending_prerender_info) OVERRIDE {
     PrerenderContents::AddPendingPrerender(pending_prerender_info.Pass());
     if (expected_pending_prerenders_ > 0 &&
         pending_prerender_count() == expected_pending_prerenders_) {
       base::MessageLoop::current()->Quit();
     }
   }
 
-  virtual WebContents* CreateWebContents(
-      content::SessionStorageNamespace* session_storage_namespace) OVERRIDE {
-    WebContents* web_contents = PrerenderContents::CreateWebContents(
-        session_storage_namespace);
-    // Create a ready title watcher. (May or may not be used.)
-    base::string16 ready_title = base::ASCIIToUTF16(kReadyTitle);
-    ready_title_watcher_.reset(new content::TitleWatcher(
-        web_contents, ready_title));
-    return web_contents;
-  }
-
-  void WaitForPrerenderToHaveReadyTitle() {
-    base::string16 ready_title = base::ASCIIToUTF16(kReadyTitle);
-    ASSERT_EQ(ready_title, ready_title_watcher_->WaitAndGetTitle());
-  }
-
   // Waits until the prerender has |expected_pending_prerenders| pending
   // prerenders.
   void WaitForPendingPrerenders(size_t expected_pending_prerenders) {
     if (pending_prerender_count() < expected_pending_prerenders) {
       expected_pending_prerenders_ = expected_pending_prerenders;
       content::RunMessageLoop();
       expected_pending_prerenders_ = 0;
     }
 
     EXPECT_EQ(expected_pending_prerenders, pending_prerender_count());
@@ skipping 52 matching lines @@
   // Set to true when the prerendering RenderWidget is shown, after having been
   // hidden.
   bool was_shown_;
   // Expected final value of was_shown_.  Defaults to true for
   // FINAL_STATUS_USED, and false otherwise.
   bool should_be_shown_;
 
   // Total number of pending prerenders we're currently waiting for.  Zero
   // indicates we currently aren't waiting for any.
   size_t expected_pending_prerenders_;
-
-  // Will wait for the title of the prerendered page to turn to "READY".
-  scoped_ptr<content::TitleWatcher> ready_title_watcher_;
 };
 
 // A handle to a TestPrerenderContents whose lifetime is under the caller's
 // control. A PrerenderContents may be destroyed at any point. This allows
 // tracking the final status, etc.
 class TestPrerender : public PrerenderContents::Observer,
                       public base::SupportsWeakPtr<TestPrerender> {
  public:
   TestPrerender()
       : contents_(NULL),
@@ skipping 480 matching lines @@
 
 // Many of these tests are flaky. See http://crbug.com/249179
 class PrerenderBrowserTest : virtual public InProcessBrowserTest {
  public:
   PrerenderBrowserTest()
       : autostart_test_server_(true),
         prerender_contents_factory_(NULL),
 #if defined(FULL_SAFE_BROWSING)
         safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
 #endif
-        use_https_src_server_(false),
         call_javascript_(true),
         check_load_events_(true),
         loader_path_("files/prerender/prerender_loader.html"),
         explicitly_set_browser_(NULL) {}
 
   virtual ~PrerenderBrowserTest() {}
 
   content::SessionStorageNamespace* GetSessionStorageNamespace() const {
-    WebContents* web_contents =
-        current_browser()->tab_strip_model()->GetActiveWebContents();
+    WebContents* web_contents = GetActiveWebContents();
     if (!web_contents)
       return NULL;
     return web_contents->GetController().GetDefaultSessionStorageNamespace();
   }
 
   virtual void SetUp() OVERRIDE {
     // TODO(danakj): The GPU Video Decoder needs real GL bindings.
     // crbug.com/269087
     UseRealGLBindings();
 
@@ skipping 29 matching lines @@
 
   virtual void SetUpOnMainThread() OVERRIDE {
     current_browser()->profile()->GetPrefs()->SetBoolean(
         prefs::kPromptForDownload, false);
     IncreasePrerenderMemory();
     if (autostart_test_server_)
       ASSERT_TRUE(test_server()->Start());
     ChromeResourceDispatcherHostDelegate::
         SetExternalProtocolHandlerDelegateForTesting(
             &external_protocol_handler_delegate_);
+
+    PrerenderManager* prerender_manager = GetPrerenderManager();
+    CHECK(prerender_manager);

[mmenke, 2014/01/21 17:16:10]

optional:  Think these could safely be ASSERTs, though if you prefer CHECKs, I
can certainly live with them.

[davidben, 2014/01/21 20:17:06]

Done.

+    prerender_manager->mutable_config().rate_limit_enabled = false;
+    CHECK(prerender_contents_factory_ == NULL);
+    prerender_contents_factory_ = new TestPrerenderContentsFactory;
+    prerender_manager->SetPrerenderContentsFactory(prerender_contents_factory_);
+  }
+
+  // Convenience function to get the currently active WebContents in
+  // current_browser().
+  WebContents* GetActiveWebContents() const {
+    return current_browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   // Overload for a single expected final status
   scoped_ptr<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
-    return PrerenderTestURL(html_file,
+    GURL url = test_server()->GetURL(html_file);
+    return PrerenderTestURL(url,
                             expected_final_status,
-                            expected_number_of_loads,
-                            false);
-  }
-
-  scoped_ptr<TestPrerender> PrerenderTestURL(
-      const std::string& html_file,
-      FinalStatus expected_final_status,
-      int expected_number_of_loads,
-      bool prerender_should_wait_for_ready_title) {
-    std::vector<FinalStatus> expected_final_status_queue(
-        1, expected_final_status);
-    std::vector<TestPrerender*> prerenders;
-    PrerenderTestURL(
-        html_file,
-        expected_final_status_queue,
-        expected_number_of_loads,
-        prerender_should_wait_for_ready_title).release(&prerenders);
-    CHECK_EQ(1u, prerenders.size());
-    return scoped_ptr<TestPrerender>(prerenders[0]);
-  }
-
-  ScopedVector<TestPrerender> PrerenderTestURL(
-      const std::string& html_file,
-      const std::vector<FinalStatus>& expected_final_status_queue,
-      int expected_number_of_loads,
-      bool prerender_should_wait_for_ready_title) {
-    GURL url = test_server()->GetURL(html_file);
-    return PrerenderTestURLImpl(url, url,
-                                expected_final_status_queue,
-                                expected_number_of_loads,
-                                prerender_should_wait_for_ready_title);
+                            expected_number_of_loads);
   }
 
   ScopedVector<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
-    return PrerenderTestURL(html_file, expected_final_status_queue,
-                            expected_number_of_loads, false);
+    GURL url = test_server()->GetURL(html_file);
+    return PrerenderTestURLImpl(url,
+                                expected_final_status_queue,
+                                expected_number_of_loads);
   }
 
   scoped_ptr<TestPrerender> PrerenderTestURL(
       const GURL& url,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
     std::vector<FinalStatus> expected_final_status_queue(
         1, expected_final_status);
     std::vector<TestPrerender*> prerenders;
-    PrerenderTestURLImpl(url, url,
+    PrerenderTestURLImpl(url,
                          expected_final_status_queue,
-                         expected_number_of_loads,
-                         false).release(&prerenders);
+                         expected_number_of_loads).release(&prerenders);
     CHECK_EQ(1u, prerenders.size());
     return scoped_ptr<TestPrerender>(prerenders[0]);
   }
-
-  scoped_ptr<TestPrerender> PrerenderTestURL(
-      const GURL& prerender_url,
-      const GURL& destination_url,
-      FinalStatus expected_final_status,
-      int expected_number_of_loads) {
-    std::vector<FinalStatus> expected_final_status_queue(
-        1, expected_final_status);
-    std::vector<TestPrerender*> prerenders;
-    PrerenderTestURLImpl(prerender_url, destination_url,
-                         expected_final_status_queue,
-                         expected_number_of_loads,
-                         false).release(&prerenders);
-    CHECK_EQ(1u, prerenders.size());
-    return scoped_ptr<TestPrerender>(prerenders[0]);
-  }
 
   void NavigateToDestURL() const {
     NavigateToDestURLWithDisposition(CURRENT_TAB, true);
   }
 
   // Opens the url in a new tab, with no opener.
   void NavigateToDestURLWithDisposition(
       WindowOpenDisposition disposition,
       bool expect_swap_to_succeed) const {
     NavigateToURLWithParams(
         content::OpenURLParams(dest_url_, Referrer(), disposition,
                                content::PAGE_TRANSITION_TYPED, false),
         expect_swap_to_succeed);
   }
 
-  void NavigateToDestUrlAndWaitForPassTitle() {
-    base::string16 expected_title = base::ASCIIToUTF16(kPassTitle);
-    content::TitleWatcher title_watcher(
-        GetPrerenderContents()->prerender_contents(),
-        expected_title);
-    NavigateToDestURL();
-    EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
-  }
-
   void NavigateToURL(const std::string& dest_html_file) const {
     NavigateToURLWithDisposition(dest_html_file, CURRENT_TAB, true);
   }
 
   void NavigateToURLWithDisposition(const std::string& dest_html_file,
                                     WindowOpenDisposition disposition,
                                     bool expect_swap_to_succeed) const {
     GURL dest_url = test_server()->GetURL(dest_html_file);
     NavigateToURLWithDisposition(dest_url, disposition, expect_swap_to_succeed);
   }
 
   void NavigateToURLWithDisposition(const GURL& dest_url,
                                     WindowOpenDisposition disposition,
                                     bool expect_swap_to_succeed) const {
     NavigateToURLWithParams(
         content::OpenURLParams(dest_url, Referrer(), disposition,
                                content::PAGE_TRANSITION_TYPED, false),
         expect_swap_to_succeed);
   }
 
   void NavigateToURLWithParams(const content::OpenURLParams& params,
                                bool expect_swap_to_succeed) const {
     NavigateToURLImpl(params, expect_swap_to_succeed);
   }
 
   void OpenDestURLViaClick() const {
-    OpenDestURLWithJSImpl("Click()", false);
+    OpenURLViaClick(dest_url_);
+  }
+
+  void OpenURLViaClick(const GURL& url) const {
+    OpenURLWithJSImpl("Click", url, false);
   }
 
   void OpenDestURLViaClickTarget() const {
-    OpenDestURLWithJSImpl("ClickTarget()", true);
+    OpenURLWithJSImpl("ClickTarget", dest_url_, true);
   }
 
   void OpenDestURLViaClickNewWindow() const {
-    OpenDestURLWithJSImpl("ShiftClick()", true);
+    OpenURLWithJSImpl("ShiftClick", dest_url_, true);
   }
 
   void OpenDestURLViaClickNewForegroundTab() const {
 #if defined(OS_MACOSX)
-    OpenDestURLWithJSImpl("MetaShiftClick()", true);
+    OpenURLWithJSImpl("MetaShiftClick", dest_url_, true);
 #else
-    OpenDestURLWithJSImpl("CtrlShiftClick()", true);
+    OpenURLWithJSImpl("CtrlShiftClick", dest_url_, true);
 #endif
   }
 
   void OpenDestURLViaClickNewBackgroundTab() const {
-    TestPrerenderContents* prerender_contents = GetPrerenderContents();
-    ASSERT_TRUE(prerender_contents != NULL);
-    prerender_contents->set_should_be_shown(false);
 #if defined(OS_MACOSX)
-    OpenDestURLWithJSImpl("MetaClick()", true);
+    OpenURLWithJSImpl("MetaClick", dest_url_, true);
 #else
-    OpenDestURLWithJSImpl("CtrlClick()", true);
+    OpenURLWithJSImpl("CtrlClick", dest_url_, true);
 #endif
   }
 
   void OpenDestURLViaWindowOpen() const {
-    OpenDestURLWithJSImpl("WindowOpen()", true);
+    OpenURLWithJSImpl("WindowOpen", dest_url_, true);
   }
 
   void RemoveLinkElement(int i) const {
-    current_browser()->tab_strip_model()->GetActiveWebContents()->
-        GetRenderViewHost()->ExecuteJavascriptInWebFrame(
+    GetActiveWebContents()->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
             base::string16(),
             base::ASCIIToUTF16(base::StringPrintf("RemoveLinkElement(%d)", i)));
   }
 
   void ClickToNextPageAfterPrerender() {
     content::WindowedNotificationObserver new_page_observer(
         content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::NotificationService::AllSources());
-    RenderViewHost* render_view_host = current_browser()->tab_strip_model()->
+    RenderViewHost* render_view_host =
         GetActiveWebContents()->GetRenderViewHost();
     render_view_host->ExecuteJavascriptInWebFrame(
         base::string16(),
         base::ASCIIToUTF16("ClickOpenLink()"));
     new_page_observer.Wait();
   }
 
   void NavigateToNextPageAfterPrerender() const {
     ui_test_utils::NavigateToURL(
         current_browser(),
         test_server()->GetURL("files/prerender/prerender_page.html"));
   }
 
   // Called after the prerendered page has been navigated to and then away from.
   // Navigates back through the history to the prerendered page.
   void GoBackToPrerender() {
     content::WindowedNotificationObserver back_nav_observer(
         content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::NotificationService::AllSources());
     chrome::GoBack(current_browser(), CURRENT_TAB);
     back_nav_observer.Wait();
     bool original_prerender_page = false;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-        current_browser()->tab_strip_model()->GetActiveWebContents(),
+        GetActiveWebContents(),
         "window.domAutomationController.send(IsOriginalPrerenderPage())",
         &original_prerender_page));
     EXPECT_TRUE(original_prerender_page);
   }
 
   // Goes back to the page that was active before the prerender was swapped
   // in. This must be called when the prerendered page is the current page
   // in the active tab.
   void GoBackToPageBeforePrerender() {
-    WebContents* tab =
-        current_browser()->tab_strip_model()->GetActiveWebContents();
+    WebContents* tab = GetActiveWebContents();
     ASSERT_TRUE(tab);
     EXPECT_FALSE(tab->IsLoading());
     TestNavigationObserver back_nav_observer(tab);
     chrome::GoBack(current_browser(), CURRENT_TAB);
     back_nav_observer.Wait();
     bool js_result;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
     return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
   }
 
   bool UrlIsInPrerenderManager(const GURL& url) const {
     return GetPrerenderManager()->FindPrerenderData(
         url, GetSessionStorageNamespace()) != NULL;
   }
 
-  void set_use_https_src(bool use_https_src_server) {
-    use_https_src_server_ = use_https_src_server;
+  void UseHttpsSrcServer() {
+    if (https_src_server_)
+      return;
+    https_src_server_.reset(
+        new net::SpawnedTestServer(
+            net::SpawnedTestServer::TYPE_HTTPS,
+            net::SpawnedTestServer::kLocalhost,
+            base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
+    CHECK(https_src_server_->Start());
   }
 
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
   void DisableLoadEventCheck() {
     check_load_events_ = false;
   }
 
@@ skipping 14 matching lines @@
     return prerender_link_manager;
   }
 
   bool DidReceivePrerenderStartEventForLinkNumber(int index) const {
     bool received_prerender_started;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send(Boolean("
             "receivedPrerenderStartEvents[%d]))", index);
 
     CHECK(content::ExecuteScriptAndExtractBool(
-        current_browser()->tab_strip_model()->GetActiveWebContents(),
+        GetActiveWebContents(),
         expression,
         &received_prerender_started));
     return received_prerender_started;
   }
 
   int GetPrerenderLoadEventCountForLinkNumber(int index) const {
     int load_event_count;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send("
             "receivedPrerenderLoadEvents[%d] || 0)", index);
 
     CHECK(content::ExecuteScriptAndExtractInt(
-        current_browser()->tab_strip_model()->GetActiveWebContents(),
+        GetActiveWebContents(),
         expression,
         &load_event_count));
     return load_event_count;
   }
 
   bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
     bool received_prerender_stopped;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send(Boolean("
             "receivedPrerenderStopEvents[%d]))", index);
 
     CHECK(content::ExecuteScriptAndExtractBool(
-        current_browser()->tab_strip_model()->GetActiveWebContents(),
+        GetActiveWebContents(),
         expression,
         &received_prerender_stopped));
     return received_prerender_stopped;
   }
 
   bool HadPrerenderEventErrors() const {
     bool had_prerender_event_errors;
     CHECK(content::ExecuteScriptAndExtractBool(
-        current_browser()->tab_strip_model()->GetActiveWebContents(),
+        GetActiveWebContents(),
         "window.domAutomationController.send(Boolean("
         "    hadPrerenderEventErrors))",
         &had_prerender_event_errors));
     return had_prerender_event_errors;
   }
 
   // Asserting on this can result in flaky tests.  PrerenderHandles are
   // removed from the PrerenderLinkManager when the prerender is canceled from
   // the browser, when the prerenders are cancelled from the renderer process,
   // or the channel for the renderer process is closed on the IO thread.  In the
@@ skipping 24 matching lines @@
   }
 #endif
 
   TestPrerenderContents* GetPrerenderContentsFor(const GURL& url) const {
     PrerenderManager::PrerenderData* prerender_data =
         GetPrerenderManager()->FindPrerenderData(url, NULL);
     return static_cast<TestPrerenderContents*>(
         prerender_data ? prerender_data->contents() : NULL);
   }
 
-  TestPrerenderContents* GetPrerenderContents() const {
-    return GetPrerenderContentsFor(dest_url_);
-  }
-
   void set_loader_path(const std::string& path) {
     loader_path_ = path;
   }
 
   void set_loader_query_and_fragment(const std::string& query_and_fragment) {
     loader_query_and_fragment_ = query_and_fragment;
   }
 
   GURL GetCrossDomainTestUrl(const std::string& path) {
     static const std::string secondary_domain = "www.foo.com";
@@ skipping 43 matching lines @@
             "window.domAutomationController.send(DidDisplayPass())",
             &display_test_result))
       return false;
     return display_test_result;
   }
 
  protected:
   bool autostart_test_server_;
 
  private:
+  // TODO(davidben): Remove this altogether so the tests don't globally assume
+  // only one prerender.
+  TestPrerenderContents* GetPrerenderContents() const {
+    return GetPrerenderContentsFor(dest_url_);
+  }
+
   ScopedVector<TestPrerender> PrerenderTestURLImpl(
       const GURL& prerender_url,
-      const GURL& destination_url,
       const std::vector<FinalStatus>& expected_final_status_queue,
-      int expected_number_of_loads,
-      bool prerender_should_wait_for_ready_title) {
-    dest_url_ = destination_url;
+      int expected_number_of_loads) {
+    dest_url_ = prerender_url;
 
     std::vector<net::SpawnedTestServer::StringPair> replacement_text;
     replacement_text.push_back(
         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;
     CHECK(net::SpawnedTestServer::GetFilePathWithReplacements(
         loader_path_,
         replacement_text,
         &replacement_path));
 
     const net::SpawnedTestServer* src_server = test_server();
-    scoped_ptr<net::SpawnedTestServer> https_src_server;
-    if (use_https_src_server_) {
-      https_src_server.reset(
-          new net::SpawnedTestServer(
-              net::SpawnedTestServer::TYPE_HTTPS,
-              net::SpawnedTestServer::kLocalhost,
-              base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
-      CHECK(https_src_server->Start());
-      src_server = https_src_server.get();
-    }
+    if (https_src_server_)
+      src_server = https_src_server_.get();
     GURL loader_url = src_server->GetURL(replacement_path +
                                          loader_query_and_fragment_);
 
-    PrerenderManager* prerender_manager = GetPrerenderManager();
-    CHECK(prerender_manager);
-    prerender_manager->mutable_config().rate_limit_enabled = false;
-    CHECK(prerender_contents_factory_ == NULL);
-    prerender_contents_factory_ = new TestPrerenderContentsFactory;
-    prerender_manager->SetPrerenderContentsFactory(prerender_contents_factory_);
-
     VLOG(1) << "Running test with queue length " <<
                expected_final_status_queue.size();
     CHECK(!expected_final_status_queue.empty());
     ScopedVector<TestPrerender> prerenders;
     for (size_t i = 0; i < expected_final_status_queue.size(); i++) {
       prerenders.push_back(
           prerender_contents_factory_->ExpectPrerenderContents(
               expected_final_status_queue[i]).release());
     }
 
@@ skipping 12 matching lines @@
       EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
     } else {
       // Otherwise, check that it prerendered correctly.
       TestPrerenderContents* prerender_contents = prerenders[0]->contents();
 
       CHECK_NE(static_cast<PrerenderContents*>(NULL), prerender_contents);
       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
       EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
 
       if (call_javascript_) {
-        // Wait for the prerendered page to change title to signal it is ready
-        // if required.
-        if (prerender_should_wait_for_ready_title)
-          prerender_contents->WaitForPrerenderToHaveReadyTitle();
-
         // Check if page behaves as expected while in prerendered state.
         EXPECT_TRUE(DidPrerenderPass(prerender_contents->prerender_contents()));
       }
     }
 
     // Test that the referring page received the right start and load events.
     EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
     if (check_load_events_) {
       EXPECT_EQ(expected_number_of_loads, prerenders[0]->number_of_loads());
       EXPECT_EQ(expected_number_of_loads,
                 GetPrerenderLoadEventCountForLinkNumber(0));
     }
     EXPECT_FALSE(HadPrerenderEventErrors());
 
     return prerenders.Pass();
   }
 
   void NavigateToURLImpl(const content::OpenURLParams& params,
                          bool expect_swap_to_succeed) const {
     ASSERT_NE(static_cast<PrerenderManager*>(NULL), GetPrerenderManager());
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_NE(static_cast<PrerenderContents*>(NULL), GetPrerenderContents());
 
-    // If opening the page in a background tab, it won't be shown when swapped
-    // in.
-    if (params.disposition == NEW_BACKGROUND_TAB)
-      GetPrerenderContents()->set_should_be_shown(false);
-
     WebContents* web_contents = GetPrerenderContents()->prerender_contents();
 
     // Navigate and wait for either the load to finish normally or for a swap to
     // occur.
     // TODO(davidben): The only handles CURRENT_TAB navigations, which is the
     // only case tested or prerendered right now.
     CHECK_EQ(CURRENT_TAB, params.disposition);
-    NavigationOrSwapObserver swap_observer(
-        current_browser()->tab_strip_model(),
-        current_browser()->tab_strip_model()->GetActiveWebContents());
+    NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
+                                           GetActiveWebContents());
     WebContents* target_web_contents = current_browser()->OpenURL(params);
     swap_observer.Wait();
 
     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 OpenDestURLWithJSImpl(const std::string& javascript_function_name,
-                             bool new_web_contents) const {
-    TestPrerenderContents* prerender_contents = GetPrerenderContents();
-    ASSERT_NE(static_cast<PrerenderContents*>(NULL), prerender_contents);
-
-    WebContents* web_contents = current_browser()->tab_strip_model()->
-        GetActiveWebContents();
-    RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
+  void OpenURLWithJSImpl(const std::string& javascript_function_name,
+                         const GURL& url,
+                         bool new_web_contents) const {
+    WebContents* web_contents = GetActiveWebContents();
+    RenderViewHost* render_view_host =
+        GetActiveWebContents()->GetRenderViewHost();
+    std::string javascript = base::StringPrintf(
+        "%s('%s')", javascript_function_name.c_str(), url.spec().c_str());
 
     if (new_web_contents) {
       NewTabNavigationOrSwapObserver observer;
       render_view_host->ExecuteJavascriptInWebFrame(
-          base::string16(), base::ASCIIToUTF16(javascript_function_name));
+          base::string16(), base::ASCIIToUTF16(javascript));
       observer.Wait();
     } else {
       NavigationOrSwapObserver observer(current_browser()->tab_strip_model(),
                                         web_contents);
       render_view_host->ExecuteJavascriptInWebFrame(
-          base::string16(), base::ASCIIToUTF16(javascript_function_name));
+          base::string16(), base::ASCIIToUTF16(javascript));
       observer.Wait();
     }
   }
 
   TestPrerenderContentsFactory* prerender_contents_factory_;
 #if defined(FULL_SAFE_BROWSING)
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
 #endif
   NeverRunsExternalProtocolHandlerDelegate external_protocol_handler_delegate_;
   GURL dest_url_;
-  bool use_https_src_server_;
+  scoped_ptr<net::SpawnedTestServer> https_src_server_;
   bool call_javascript_;
   bool check_load_events_;
   std::string loader_path_;
   std::string loader_query_and_fragment_;
   Browser* explicitly_set_browser_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prerender> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   ChannelDestructionWatcher channel_close_watcher;
-  channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
+  channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that pending prerenders launch and receive proper event treatment.
 // Disabled due to http://crbug.com/167792
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderPagePending) {
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   PrerenderTestURL("files/prerender/prerender_page_pending.html",
                    expected_final_status_queue, 1);
 
   ChannelDestructionWatcher first_channel_close_watcher;
 
-  first_channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
+  first_channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   // NavigateToDestURL doesn't run a message loop. Normally that's fine, but in
   // this case, we need the pending prerenders to start.
   content::RunMessageLoop();
   first_channel_close_watcher.WaitForChannelClose();
 
   const GURL prerender_page_url =
       test_server()->GetURL("files/prerender/prerender_page.html");
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
   EXPECT_NE(static_cast<TestPrerenderContents*>(NULL),
             GetPrerenderContentsFor(prerender_page_url));
 
   // Now navigate to our target page.
   ChannelDestructionWatcher second_channel_close_watcher;
-  second_channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
+  second_channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), prerender_page_url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   second_channel_close_watcher.WaitForChannelClose();
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that pending prerenders which are canceled before they are launched
 // never get started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovesPending) {
   PrerenderTestURL("files/prerender/prerender_page_removes_pending.html",
                    FINAL_STATUS_USED, 1);
 
   ChannelDestructionWatcher channel_close_watcher;
-  channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
+  channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   EXPECT_FALSE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
   EXPECT_FALSE(HadPrerenderEventErrors());
   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
   // calls did a thread/process hop to the renderer which insured pending
   // renderer events have arrived.
@@ skipping 76 matching lines @@
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
   EXPECT_FALSE(HadPrerenderEventErrors());
   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
   // calls did a thread/process hop to the renderer which insured pending
   // renderer events have arrived.
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   ChannelDestructionWatcher channel_close_watcher;
-  channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
+  channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
-// Checks that prerendering works in incognito mode.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderIncognito) {
-  Profile* normal_profile = current_browser()->profile();
-  set_browser(
-      ui_test_utils::OpenURLOffTheRecord(normal_profile, GURL("about:blank")));
-  // Increase memory expectations on the incognito PrerenderManager.
-  IncreasePrerenderMemory();
-  PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
-  NavigateToDestURL();
-}
-
 // Checks that the visibility API works.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderVisibility) {
   PrerenderTestURL("files/prerender/prerender_visibility.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the prerendering of a page is canceled correctly if we try to
@@ skipping 104 matching lines @@
   NavigateToDestURL();
 
 
   // Run this check again.  When we try to load aa ppapi plugin, the
   // "loadstart" event is asynchronously posted to a message loop.
   // It's possible that earlier call could have been run before the
   // the "loadstart" event was posted.
   // TODO(mmenke):  While this should reliably fail on regressions, the
   //                reliability depends on the specifics of ppapi plugin
   //                loading.  It would be great if we could avoid that.
-  WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  EXPECT_TRUE(DidDisplayPass(web_contents));
+  EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 }
 
 // Checks that plugins in an iframe are not loaded while a page is
 // being preloaded, but are loaded when the page is displayed.
 #if defined(USE_AURA) && !defined(OS_WIN)
 // http://crbug.com/103496
 #define MAYBE_PrerenderIframeDelayLoadPlugin \
         DISABLED_PrerenderIframeDelayLoadPlugin
 #elif defined(OS_MACOSX)
 // http://crbug.com/100514
@@ skipping 67 matching lines @@
 
 // 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,
     DISABLED_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();
+  PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 2);
+  OpenURLViaClick(destination_url);
 }
 
 // Checks that a prerender for an https will prevent a prerender from happening.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttps) {
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS, net::SpawnedTestServer::kLocalhost,
       base::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,
@@ skipping 84 matching lines @@
 
 // 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();
+  PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
+  OpenURLViaClick(destination_url);
 }
 
 // Checks that server-issued redirects from an http to an https
 // location will cancel prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectToHttps) {
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS, net::SpawnedTestServer::kLocalhost,
       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
@@ skipping 77 matching lines @@
   PrerenderTestURL("files/prerender/prerender_referrer.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer is not set when prerendering and the source page is
 // HTTPS.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderNoSSLReferrer) {
-  set_use_https_src(true);
+  UseHttpsSrcServer();
   PrerenderTestURL("files/prerender/prerender_no_referrer.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer is set when prerendering is cancelled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrer) {
   scoped_ptr<TestContentBrowserClient> test_content_browser_client(
       new TestContentBrowserClient);
   content::ContentBrowserClient* original_browser_client =
       content::SetBrowserClientForTesting(test_content_browser_client.get());
 
   PrerenderTestURL("files/prerender/prerender_referrer.html",
                    FINAL_STATUS_CANCELLED,
                    1);
   OpenDestURLViaClick();
 
-  bool display_test_result = false;
-  WebContents* web_contents =
-      browser()->tab_strip_model()->GetActiveWebContents();
-  ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
-      web_contents,
-      "window.domAutomationController.send(DidDisplayPass())",
-      &display_test_result));
-  EXPECT_TRUE(display_test_result);
+  EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 
   content::SetBrowserClientForTesting(original_browser_client);
 }
 
 // Checks that popups on a prerendered page cause cancellation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPopup) {
   PrerenderTestURL("files/prerender/prerender_popup.html",
                    FINAL_STATUS_CREATE_NEW_WINDOW,
                    0);
 }
@@ skipping 31 matching lines @@
 // TODO(gavinp,sreeram): Fix http://crbug.com/145248 and deflake this test.
 // Checks that we don't prerender in an infinite loop.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderInfiniteLoop) {
   const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
   const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
-  PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
-  ASSERT_TRUE(GetPrerenderContents());
-  GetPrerenderContents()->WaitForPendingPrerenders(1u);
+  ScopedVector<TestPrerender> prerenders =
+      PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
+  ASSERT_TRUE(prerenders[0]->contents());
+  prerenders[0]->contents()->WaitForPendingPrerenders(1u);
 
   // Next url should be in pending list but not an active entry.
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
 
   NavigateToDestURL();
 
   // Make sure the PrerenderContents for the next url is now in the manager
   // and not pending.
   EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
 }
@@ skipping 13 matching lines @@
   // This test is conceptually simplest if concurrency is at two, since we
   // don't have to worry about which of kHtmlFileB or kHtmlFileC gets evicted.
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
-  PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
-  ASSERT_TRUE(GetPrerenderContents());
-  GetPrerenderContents()->WaitForPendingPrerenders(2u);
+  ScopedVector<TestPrerender> prerenders =
+      PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
+  ASSERT_TRUE(prerenders[0]->contents());
+  prerenders[0]->contents()->WaitForPendingPrerenders(2u);
 
   // Next url should be in pending list but not an active entry.
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileC));
 
   NavigateToDestURL();
 
   // Make sure the PrerenderContents for the next urls are now in the manager
   // and not pending. One and only one of the URLs (the last seen) should be the
   // active entry.
@@ skipping 64 matching lines @@
   // We may have deleted the prerender tab, but the swapped in tab should be
   // active.
   EXPECT_GE(num_tabs_with_prerender_page_title, 1);
   EXPECT_LE(num_tabs_with_prerender_page_title, 2);
 }
 
 // Checks that audio loads are deferred on prerendering.
 // Times out under AddressSanitizer, see http://crbug.com/108402
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderHTML5Audio) {
   PrerenderTestURL("files/prerender/prerender_html5_audio.html",
-                  FINAL_STATUS_USED,
-                  1);
-  NavigateToDestUrlAndWaitForPassTitle();
+                   FINAL_STATUS_USED,
+                   1);
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that audio loads are deferred on prerendering and played back when
 // the prerender is swapped in if autoplay is set.
 // Periodically fails on chrome-os.  See http://crbug.com/145263
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderHTML5AudioAutoplay) {
   PrerenderTestURL("files/prerender/prerender_html5_audio_autoplay.html",
                    FINAL_STATUS_USED,
                    1);
-  NavigateToDestUrlAndWaitForPassTitle();
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that audio loads are deferred on prerendering and played back when
 // the prerender is swapped in if js starts playing.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderHTML5AudioJsplay) {
   PrerenderTestURL("files/prerender/prerender_html5_audio_jsplay.html",
                    FINAL_STATUS_USED,
                    1);
-  NavigateToDestUrlAndWaitForPassTitle();
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that video loads are deferred on prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderHTML5Video) {
   PrerenderTestURL("files/prerender/prerender_html5_video.html",
                    FINAL_STATUS_USED,
                    1);
-  NavigateToDestUrlAndWaitForPassTitle();
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that video tags inserted by javascript are deferred and played
 // correctly on swap in.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderHTML5VideoJs) {
   PrerenderTestURL("files/prerender/prerender_html5_video_script.html",
                    FINAL_STATUS_USED,
                    1);
-  NavigateToDestUrlAndWaitForPassTitle();
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks for correct network events by using a busy sleep the javascript.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderHTML5VideoNetwork) {
-  PrerenderTestURL("files/prerender/prerender_html5_video_network.html",
-                   FINAL_STATUS_USED,
-                   1,
-                   true);
-  NavigateToDestUrlAndWaitForPassTitle();
+  DisableJavascriptCalls();
+  scoped_ptr<TestPrerender> prerender =
+      PrerenderTestURL("files/prerender/prerender_html5_video_network.html",
+                       FINAL_STATUS_USED,
+                       1);
+  WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
+  EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that scripts can retrieve the correct window size while prerendering.
 #if defined(TOOLKIT_VIEWS)
 // TODO(beng): Widget hierarchy split causes this to fail http://crbug.com/82363
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderWindowSize) {
 #else
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowSize) {
 #endif
   PrerenderTestURL("files/prerender/prerender_size.html",
@@ skipping 477 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageWrite) {
   PrerenderTestURL("files/prerender/prerender_localstorage_write.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the favicon is properly loaded on prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderFavicon) {
-  PrerenderTestURL("files/prerender/prerender_favicon.html",
-                   FINAL_STATUS_USED,
-                   1);
-  TestPrerenderContents* prerender_contents = GetPrerenderContents();
-  ASSERT_TRUE(prerender_contents != NULL);
+  scoped_ptr<TestPrerender> prerender =
+      PrerenderTestURL("files/prerender/prerender_favicon.html",
+                       FINAL_STATUS_USED,
+                       1);
+  ASSERT_TRUE(prerender->contents());
   content::WindowedNotificationObserver favicon_update_watcher(
       chrome::NOTIFICATION_FAVICON_UPDATED,
-      content::Source<WebContents>(prerender_contents->prerender_contents()));
+      content::Source<WebContents>(
+          prerender->contents()->prerender_contents()));
   NavigateToDestURL();
   favicon_update_watcher.Wait();
 }
 
 // Checks that when a prerendered page is swapped in to a referring page, the
 // unload handlers on the referring page are executed.
 // Fails about 50% on CrOS, 5-10% on linux, win, mac. http://crbug.com/128986
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderUnload) {
   set_loader_path("files/prerender/prerender_loader_with_unload.html");
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
@@ skipping 44 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL("files/prerender/prerender_page.html",
                        FINAL_STATUS_CANCELLED,
                        1);
 
   GetPrerenderManager()->CancelAllPrerenders();
   prerender->WaitForStop();
 
-  EXPECT_TRUE(GetPrerenderContents() == NULL);
+  EXPECT_FALSE(prerender->contents());
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEvents) {
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL("files/prerender/prerender_page.html",
                        FINAL_STATUS_CANCELLED, 1);
 
   GetPrerenderManager()->CancelAllPrerenders();
   prerender->WaitForStop();
 
   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
   EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
   EXPECT_FALSE(HadPrerenderEventErrors());
 }
 
 // Cancels the prerender of a page with its own prerender.  The second prerender
 // should never be started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelPrerenderWithPrerender) {
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL("files/prerender/prerender_infinite_a.html",
                        FINAL_STATUS_CANCELLED,
                        1);
 
   GetPrerenderManager()->CancelAllPrerenders();
   prerender->WaitForStop();
 
-  EXPECT_TRUE(GetPrerenderContents() == NULL);
+  EXPECT_FALSE(prerender->contents());
 }
 
 // Prerendering and history tests.
 // The prerendered page is navigated to in several ways [navigate via
 // omnibox, click on link, key-modified click to open in background tab, etc],
 // followed by a navigation to another page from the prerendered page, followed
 // by a back navigation.
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderNavigateClickGoBack) {
@@ skipping 48 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewForegroundTab) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
                    FINAL_STATUS_WINDOW_OPENER,
                    1);
   OpenDestURLViaClickNewForegroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderClickNewBackgroundTab) {
-  PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_APP_TERMINATING,
-                   1);
+  scoped_ptr<TestPrerender> prerender =
+      PrerenderTestURL("files/prerender/prerender_page_with_link.html",
+                       FINAL_STATUS_APP_TERMINATING,
+                       1);
+  ASSERT_TRUE(prerender->contents());
+  prerender->contents()->set_should_be_shown(false);
   OpenDestURLViaClickNewBackgroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        NavigateToPrerenderedPageWhenDevToolsAttached) {
   DisableJavascriptCalls();
   WebContents* web_contents =
       current_browser()->tab_strip_model()->GetActiveWebContents();
   scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetOrCreateFor(
       web_contents->GetRenderViewHost()));
@@ skipping 84 matching lines @@
   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer policy is used when prerendering on HTTPS.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSSLReferrerPolicy) {
-  set_use_https_src(true);
+  UseHttpsSrcServer();
   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 // Checks that the referrer policy is used when prerendering is cancelled.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrerPolicy) {
   scoped_ptr<TestContentBrowserClient> test_content_browser_client(
@@ skipping 195 matching lines @@
   GURL url = test_server()->GetURL(
       CreateServerRedirect("invalidscheme://www.google.com/test.html"));
   PrerenderTestURL(url, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
 }
 
 // Checks that media source video loads are deferred on prerendering.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5MediaSourceVideo) {
   PrerenderTestURL("files/prerender/prerender_html5_video_media_source.html",
                    FINAL_STATUS_USED,
                    1);
-  NavigateToDestUrlAndWaitForPassTitle();
+  NavigateToDestURL();
+  WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
 }
 
 // Checks that a prerender that creates an audio stream (via a WebAudioDevice)
 // is cancelled.
 // http://crbug.com/261489
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderWebAudioDevice) {
   PrerenderTestURL("files/prerender/prerender_web_audio_device.html",
                    FINAL_STATUS_CREATING_AUDIO_STREAM, 1);
 }
 
 // Checks that prerenders do not swap in to WebContents being captured.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCapturedWebContents) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_PAGE_BEING_CAPTURED, 1);
-  WebContents* web_contents =
-      current_browser()->tab_strip_model()->GetActiveWebContents();
+  WebContents* web_contents = GetActiveWebContents();
   web_contents->IncrementCapturerCount();
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
   web_contents->DecrementCapturerCount();
 }
 
 // Checks that prerenders are aborted on cross-process navigation from
 // a server redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCrossProcessServerRedirect) {
   // Force everything to be a process swap.
@@ skipping 43 matching lines @@
   GetPrerenderManager()->CancelAllPrerenders();
   prerenders[1]->WaitForStop();
 
   // Check the referring page only got one copy of the event.
   EXPECT_FALSE(HadPrerenderEventErrors());
 }
 
 // Checks that a deferred redirect to an image is not loaded until the
 // page is visible.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredImage) {
-  // We do NOT wait for a load event, as the image will block the
-  // load. Instead, wait for the title to change.
+  DisableJavascriptCalls();
+
+  // The prerender will not completely load until after the swap, so wait for a
+  // title change before calling DidPrerenderPass.
   scoped_ptr<TestPrerender> prerender =
-      PrerenderTestURL("files/prerender/prerender_deferred_image.html",
-                       FINAL_STATUS_USED, 0, true);
-
-  // The prerender hasn't loaded yet because its image is deferred.
+      PrerenderTestURL(
+          "files/prerender/prerender_deferred_image.html",
+          FINAL_STATUS_USED, 0);
+  WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
+  EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(0, prerender->number_of_loads());
 
-  // Navigate, waiting for both the swap and an extra load from the prerender.
-  // The swap happens before the load, so |prerender->WaitForLoads(1)| doesn't
-  // work.
-  content::WindowedNotificationObserver page_load_observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::Source<NavigationController>(
-          &prerender->contents()->prerender_contents()->GetController()));
-  NavigationOrSwapObserver swap_observer(
-      current_browser()->tab_strip_model(),
-      current_browser()->tab_strip_model()->GetActiveWebContents());
+  // Swap.
+  NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
+                                         GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), dest_url(), CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
-  page_load_observer.Wait();
 
-  // The prerender never observed the final load.
+  // The page only finishes navigating after the swap. Wait for it to if it
+  // hasn't yet.
+  content::WaitForLoadStop(GetActiveWebContents());
+
+  // The prerender never observes the final load.
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Now check DidDisplayPass.
-  EXPECT_TRUE(DidDisplayPass(
-      current_browser()->tab_strip_model()->GetActiveWebContents()));
+  EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 }
 
 // Checks that a deferred redirect to an image is not loaded until the
 // page is visible, even after another redirect.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderDeferredImageAfterRedirect) {
-  // We do NOT wait for a load event, as the image will block the
-  // load. Instead, wait for the title to change.
+  DisableJavascriptCalls();
+
+  // The prerender will not completely load until after the swap, so wait for a
+  // title change before calling DidPrerenderPass.
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL(
-          "files/prerender/prerender_deferred_image.html#double_redirect",
-          FINAL_STATUS_USED, 0, true);
-
-  // The prerender hasn't loaded yet because its image is deferred.
+          "files/prerender/prerender_deferred_image.html",
+          FINAL_STATUS_USED, 0);
+  WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
+  EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(0, prerender->number_of_loads());
 
-  // Navigate, waiting for both the swap and an extra load from the prerender.
-  // The swap happens before the load, so |prerender->WaitForLoads(1)| doesn't
-  // work.
-  content::WindowedNotificationObserver page_load_observer(
-      content::NOTIFICATION_LOAD_STOP,
-      content::Source<NavigationController>(
-          &prerender->contents()->prerender_contents()->GetController()));
-  NavigationOrSwapObserver swap_observer(
-      current_browser()->tab_strip_model(),
-      current_browser()->tab_strip_model()->GetActiveWebContents());
+  // Swap.
+  NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
+                                         GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), dest_url(), CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
   swap_observer.Wait();
-  page_load_observer.Wait();
 
-  // The prerender never observed the final load.
+  // The page only finishes navigating after the swap. Wait for it to if it
+  // hasn't yet.
+  content::WaitForLoadStop(GetActiveWebContents());
+
+  // The prerender never observes the final load.
   EXPECT_EQ(0, prerender->number_of_loads());
 
   // Now check DidDisplayPass.
-  EXPECT_TRUE(DidDisplayPass(
-      current_browser()->tab_strip_model()->GetActiveWebContents()));
+  EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 }
 
 // Checks that deferred redirects in the main frame are followed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredMainFrame) {
   DisableJavascriptCalls();
   PrerenderTestURL(
       "files/prerender/image-deferred.png",
       FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
@@ skipping 132 matching lines @@
 
   // Now navigate in the new tab. Set expect_swap_to_succeed to false because
   // the swap does not occur synchronously.
   //
   // TODO(davidben): When all swaps become asynchronous, remove the OpenURL
   // return value assertion and let this go through the usual successful-swap
   // codepath.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 
   // Verify DidDisplayPass manually since the previous call skipped it.
-  EXPECT_TRUE(DidDisplayPass(
-      current_browser()->tab_strip_model()->GetActiveWebContents()));
+  EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 
   // Only one request to the test URL started.
   EXPECT_EQ(1, counter.count());
 }
 
 // Verify that session storage conflicts don't merge.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorageConflict) {
   PrerenderTestURL("files/prerender/prerender_session_storage_conflict.html",
                    FINAL_STATUS_APP_TERMINATING, 1);
 
   // Open a new tab to navigate in.
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(),
       test_server()->GetURL("files/prerender/init_session_storage.html"),
       NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
   // Now navigate in the new tab.
   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
 
   // Verify DidDisplayPass in the new tab.
-  EXPECT_TRUE(DidDisplayPass(
-      current_browser()->tab_strip_model()->GetActiveWebContents()));
+  EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
 }
 
 // Checks that prerenders honor |should_replace_current_entry|.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReplaceCurrentEntry) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
                                 content::PAGE_TRANSITION_TYPED, false);
   params.should_replace_current_entry = true;
   NavigateToURLWithParams(params, false);
 
-  WebContents* web_contents =
-      current_browser()->tab_strip_model()->GetActiveWebContents();
-  const NavigationController& controller = web_contents->GetController();
+  const NavigationController& controller =
+      GetActiveWebContents()->GetController();
   // First entry is about:blank, second is prerender_page.html.
   EXPECT_TRUE(controller.GetPendingEntry() == NULL);
   EXPECT_EQ(2, controller.GetEntryCount());
   EXPECT_EQ(GURL(content::kAboutBlankURL),
             controller.GetEntryAtIndex(0)->GetURL());
   EXPECT_EQ(dest_url(), controller.GetEntryAtIndex(1)->GetURL());
 }
 
+class PrerenderIncognitoBrowserTest : public PrerenderBrowserTest {
+ public:
+  virtual void SetUpOnMainThread() OVERRIDE {
+    Profile* normal_profile = current_browser()->profile();
+    set_browser(ui_test_utils::OpenURLOffTheRecord(
+        normal_profile, GURL("about:blank")));
+    PrerenderBrowserTest::SetUpOnMainThread();
+  }
+};
+
+// 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