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 41 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_filter.h"
+#include "net/url_request/url_request_job.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::DevToolsClientHost;
 using content::DevToolsManager;
 using content::NavigationController;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
@@ skipping 500 matching lines @@
 class RestorePrerenderMode {
  public:
   RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
   }
 
   ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
  private:
   PrerenderManager::PrerenderManagerMode prev_mode_;
 };
 
+// URLRequestJob (and associated handler) which never starts.
+class NeverStartURLRequestJob : public net::URLRequestJob {
+ public:
+  NeverStartURLRequestJob(net::URLRequest* request,
+                          net::NetworkDelegate* network_delegate)
+      : net::URLRequestJob(request, network_delegate) {
+  }
+
+  virtual void Start() OVERRIDE {}
+
+ private:
+  virtual ~NeverStartURLRequestJob() {}
+};
+
+class NeverStartProtocolHandler
+    : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  NeverStartProtocolHandler() {}
+  virtual ~NeverStartProtocolHandler() {}
+
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return new NeverStartURLRequestJob(request, network_delegate);
+  }
+};
+
+void CreateNeverStartProtocolHandlerOnIO(const GURL& url) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  scoped_ptr<net::URLRequestJobFactory::ProtocolHandler> never_respond_handler(
+      new NeverStartProtocolHandler());
+  net::URLRequestFilter::GetInstance()->AddUrlProtocolHandler(
+      url, never_respond_handler.Pass());
+}
+
 }  // namespace
 
 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
@@ skipping 102 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.
+  const GURL kNoCommitUrl("http://never-respond.example.com");
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateNeverStartProtocolHandlerOnIO, kNoCommitUrl));
+  PrerenderTestURL(kNoCommitUrl,
+                   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(kNoCommitUrl));
+
+  // 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