Replace PruneAllButActive with PruneAllButVisible.

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/command_line.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
@@ skipping 683 matching lines @@
       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,
                          false);
   }
 
   void NavigateToDestURL() const {
-    NavigateToDestURLWithDisposition(CURRENT_TAB);
+    NavigateToDestURLWithDisposition(CURRENT_TAB, true);
   }
 
   // Opens the url in a new tab, with no opener.
   void NavigateToDestURLWithDisposition(
-      WindowOpenDisposition disposition) const {
-    NavigateToURLImpl(dest_url_, disposition);
+      WindowOpenDisposition disposition,
+      bool expect_swap_to_succeed) const {
+    NavigateToURLImpl(dest_url_, disposition, expect_swap_to_succeed);
   }
 
   void OpenDestURLViaClick() const {
     OpenDestURLWithJSImpl("Click()");
   }
 
   void OpenDestURLViaClickTarget() const {
     OpenDestURLWithJSImpl("ClickTarget()");
   }
 
@@ skipping 90 matching lines @@
     bool js_result;
     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
         tab,
         "window.domAutomationController.send(DidBackToOriginalPagePass())",
         &js_result));
     EXPECT_TRUE(js_result);
   }
 
   void NavigateToURL(const std::string& dest_html_file) const {
     GURL dest_url = test_server()->GetURL(dest_html_file);
-    NavigateToURLImpl(dest_url, CURRENT_TAB);
+    NavigateToURLImpl(dest_url, CURRENT_TAB, true);
   }
 
   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;
   }
@@ skipping 246 matching lines @@
       // In the failure case, we should have removed |dest_url_| from the
       // prerender_manager.  We ignore dummy PrerenderContents (as indicated
       // by not having started), and PrerenderContents that are expected to
       // be left in the manager until the test finishes.
       EXPECT_TRUE(prerender_contents == NULL ||
                   !prerender_contents->prerendering_has_started());
     }
   }
 
   void NavigateToURLImpl(const GURL& dest_url,
-                         WindowOpenDisposition disposition) const {
+                         WindowOpenDisposition disposition,
+                         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 (disposition == NEW_BACKGROUND_TAB)
       GetPrerenderContents()->set_should_be_shown(false);
 
     scoped_ptr<content::WindowedNotificationObserver> page_load_observer;
@@ skipping 12 matching lines @@
       }
     }
 
     // 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(
         current_browser(), dest_url, disposition,
         ui_test_utils::BROWSER_TEST_NONE);
 
-    // Make sure the PrerenderContents found earlier was used or removed.
-    EXPECT_EQ(static_cast<PrerenderContents*>(NULL), GetPrerenderContents());
+    // Make sure the PrerenderContents found earlier was used or removed,
+    // unless we expect the swap in to fail.
+    EXPECT_EQ(expect_swap_to_succeed, !GetPrerenderContents());
 
-    if (call_javascript_ && web_contents) {
+    if (call_javascript_ && web_contents && expect_swap_to_succeed) {
       if (page_load_observer.get())
         page_load_observer->Wait();
 
       bool display_test_result = false;
       ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
           web_contents,
           "window.domAutomationController.send(DidDisplayPass())",
           &display_test_result));
       EXPECT_TRUE(display_test_result);
     }
@@ skipping 223 matching lines @@
 }
 
 // Checks that the visibility API works.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibility) {
   PrerenderTestURL("files/prerender/prerender_visibility.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
-// Checks that the visibility API works when the prerender is quickly opened
-// in a new tab before it stops loading.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibilityQuickSwitch) {
-  PrerenderTestURL("files/prerender/prerender_visibility_quick.html",
-                   FINAL_STATUS_USED, 0);
-  NavigateToDestURL();
+// Checks that the prerendering of a page is canceled correctly if we try to
+// swap it in before it commits.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap) {
+  // Navigate to a page that triggers a prerender for a URL that never commits.
+  // TODO(creis): Use a mock HTTP job for a URL that never commits.
+  const GURL no_commit_url = test_server()->GetURL("/slow?5");

[Charlie Reis, 2013/05/29 22:30:52]

This needs to be replaced with a request that doesn't commit.

+  PrerenderTestURL(no_commit_url,
+                   FINAL_STATUS_CANCELLED,
+                   0);
+
+  // Navigate to the URL, but assume the contents won't be swapped in.
+  NavigateToDestURLWithDisposition(CURRENT_TAB, false);
+
+  // Confirm that the prerendered version of the URL is not swapped in,
+  // since it never committed.
+  EXPECT_TRUE(UrlIsInPrerenderManager(no_commit_url));
+
+  // Post a task to cancel all the prerenders, so that we don't wait further.
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&CancelAllPrerenders, GetPrerenderManager()));
+  content::RunMessageLoop();
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
   PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
                    FINAL_STATUS_JAVASCRIPT_ALERT,
                    1);
 }
 
@@ skipping 1404 matching lines @@
 // Checks that non-http/https main page redirects cancel the prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderCancelMainFrameRedirectUnsupportedScheme) {
   GURL url = test_server()->GetURL(
       CreateServerRedirect("invalidscheme://www.google.com/test.html"));
   PrerenderTestURL(url, FINAL_STATUS_UNSUPPORTED_SCHEME, 1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender