Add pending preloads indexed by routing id. Start preloading once we navigate.

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 "base/command_line.h"
 #include "base/path_service.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 67 matching lines @@
 };
 
 // PrerenderManager that uses TestPrerenderContents.
 class WaitForLoadPrerenderContentsFactory : public PrerenderContents::Factory {
  public:
   explicit WaitForLoadPrerenderContentsFactory(
       FinalStatus expected_final_status)
       : expected_final_status_(expected_final_status) {
   }
 
+  void set_expected_final_status(FinalStatus expected_final_status) {
+    expected_final_status_ = expected_final_status;
+  }
+
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager, Profile* profile, const GURL& url,
       const std::vector<GURL>& alias_urls, const GURL& referrer) {
     return new TestPrerenderContents(prerender_manager, profile, url,
                                      alias_urls, referrer,
                                      expected_final_status_);
   }
 
  private:
   FinalStatus expected_final_status_;
@@ skipping 18 matching lines @@
     command_line->AppendSwitchPath(
         switches::kExtraPluginDir,
         app_dir.Append(FILE_PATH_LITERAL("plugins")));
 #endif
   }
 
   void PrerenderTestURL(const std::string& html_file,
                         FinalStatus expected_final_status,
                         int total_navigations) {
     ASSERT_TRUE(test_server()->Start());
-    std::string dest_path = "files/prerender/";
-    dest_path.append(html_file);
-    dest_url_ = test_server()->GetURL(dest_path);
+    dest_url_ = UrlForHtmlFile(html_file);
 
     std::vector<net::TestServer::StringPair> replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_PREFETCH_URL", dest_url_.spec()));
     std::string replacement_path;
     ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
         "files/prerender/prerender_loader.html",
         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(
           new net::TestServer(net::TestServer::TYPE_HTTPS,
                               FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
       ASSERT_TRUE(https_src_server->Start());
       src_server = https_src_server.get();
     }
     GURL src_url = src_server->GetURL(replacement_path);
 
-    Profile* profile = browser()->GetSelectedTabContents()->profile();
-    PrerenderManager* prerender_manager = profile->GetPrerenderManager();
-    ASSERT_TRUE(prerender_manager);
-
     // This is needed to exit the event loop once the prerendered page has
     // stopped loading or was cancelled.
-    prerender_manager->SetPrerenderContentsFactory(
+    ASSERT_TRUE(prerender_manager());
+    prerender_manager()->SetPrerenderContentsFactory(
         new WaitForLoadPrerenderContentsFactory(expected_final_status));
 
     // ui_test_utils::NavigateToURL uses its own observer and message loop.
     // Since the test needs to wait until the prerendered page has stopped
     // loading, rathather than the page directly navigated to, need to
     // handle browser navigation directly.
     browser()->OpenURL(src_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
 
     TestPrerenderContents* prerender_contents = NULL;
     int navigations = 0;
     while (true) {
       ui_test_utils::RunMessageLoop();
       ++navigations;
 
       prerender_contents =
           static_cast<TestPrerenderContents*>(
-              prerender_manager->FindEntry(dest_url_));
+              prerender_manager()->FindEntry(dest_url_));
       if (prerender_contents == NULL ||
           !prerender_contents->did_finish_loading() ||
           navigations >= total_navigations) {
         EXPECT_EQ(navigations, total_navigations);
         break;
       }
       prerender_contents->set_did_finish_loading(false);
     }
 
     switch (expected_final_status) {
@@ skipping 14 matching lines @@
         // In the failure case, we should have removed dest_url_ from the
         // prerender_manager.
         EXPECT_TRUE(prerender_contents == NULL);
         break;
     }
   }
 
   void NavigateToDestURL() const {
     ui_test_utils::NavigateToURL(browser(), dest_url_);
 
-    Profile* profile = browser()->GetSelectedTabContents()->profile();
-    PrerenderManager* prerender_manager = profile->GetPrerenderManager();
-    ASSERT_TRUE(prerender_manager);
-
     // Make sure the PrerenderContents found earlier was used or removed
-    EXPECT_TRUE(prerender_manager->FindEntry(dest_url_) == NULL);
+    EXPECT_TRUE(prerender_manager()->FindEntry(dest_url_) == NULL);
 
     // Check if page behaved as expected when actually displayed.
     bool display_test_result = false;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
         browser()->GetSelectedTabContents()->render_view_host(), L"",
         L"window.domAutomationController.send(DidDisplayPass())",
         &display_test_result));
     EXPECT_TRUE(display_test_result);
   }
 
+  bool UrlIsInPrerenderManager(const std::string& url) {
+    GURL dest_url = UrlForHtmlFile(url);
+
+    return (prerender_manager()->FindEntry(dest_url) != NULL);
+  }
+
+  bool UrlIsPendingInPrerenderManager(const std::string& url) {
+    GURL dest_url = UrlForHtmlFile(url);
+
+    typedef std::map<int, PrerenderManager::PendingContentsData> PendingMap;
+    PendingMap& pending_map = prerender_manager()->pending_prerender_map_;
+    for (PendingMap::iterator it = pending_map.begin();
+         it != pending_map.end(); ++it) {
+      if (it->second.url_ == dest_url)
+        return true;
+    }
+    return false;
+  }
+
+  GURL UrlForHtmlFile(const std::string& html_file) {
+    std::string dest_path = "files/prerender/";
+    dest_path.append(html_file);
+    return test_server()->GetURL(dest_path);
+  }
+
+  PrerenderManager* prerender_manager() const {
+    Profile* profile = browser()->GetSelectedTabContents()->profile();
+    PrerenderManager* prerender_manager = profile->GetPrerenderManager();
+    return prerender_manager;
+  }
+
   void set_use_https_src(bool use_https_src_server) {
     use_https_src_server_ = use_https_src_server;
   }
 
+  void SetExpectedFinalStatus(FinalStatus expected_final_status) {
+    WaitForLoadPrerenderContentsFactory* prc_factory =
+        static_cast<WaitForLoadPrerenderContentsFactory*>(
+            prerender_manager()->prerender_contents_factory_.get());
+    prc_factory->set_expected_final_status(expected_final_status);
+  }
+
  private:
   GURL dest_url_;
   bool use_https_src_server_;
 };
 
 // Checks that a page is correctly prerendered in the case of a
 // <link rel=prefetch> tag and then loaded into a tab in response to a
 // navigation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
   PrerenderTestURL("prerender_page.html",
                    FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
-  PrerenderTestURL(
-      "prerender_alert_before_onload.html",
-      FINAL_STATUS_JAVASCRIPT_ALERT, 1);
+  PrerenderTestURL("prerender_alert_before_onload.html",
+                   FINAL_STATUS_JAVASCRIPT_ALERT, 1);
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertAfterOnload) {
-  PrerenderTestURL(
-      "prerender_alert_after_onload.html",
-      FINAL_STATUS_JAVASCRIPT_ALERT, 1);
+  PrerenderTestURL("prerender_alert_after_onload.html",
+                   FINAL_STATUS_JAVASCRIPT_ALERT, 1);
 }
 
 // Checks that plugins are not loaded while a page is being preloaded, but
 // are loaded when the page is displayed.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDelayLoadPlugin) {
   PrerenderTestURL("plugin_delay_load.html",
                    FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
@@ skipping 80 matching lines @@
                    FINAL_STATUS_HTTPS,
                    2);
 }
 
 // Checks that renderers using excessive memory will be terminated.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
   PrerenderTestURL("prerender_excessive_memory.html",
                    FINAL_STATUS_MEMORY_LIMIT_EXCEEDED, 1);
 }
 
+// Checks that we don't prerender in an infinite loop.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderInfiniteLoop) {
+  const char* url_a = "prerender_infinite_a.html";
+  const char* url_b = "prerender_infinite_b.html";
+
+  PrerenderTestURL(url_a, FINAL_STATUS_USED, 1);
+
+  // Next url should be in pending list but not an active entry.
+  EXPECT_FALSE(UrlIsInPrerenderManager(url_b));
+  EXPECT_TRUE(UrlIsPendingInPrerenderManager(url_b));
+
+  // We are not going to navigate back to url_a but we will start the preload so
+  // we need to set the final status to expect here before navigating to url_b.
+  SetExpectedFinalStatus(FINAL_STATUS_APP_TERMINATING);
+
+  NavigateToDestURL();
+
+  // Make sure the PrerenderContents for the next url is now in the manager
+  // and not pending.
+  EXPECT_TRUE(UrlIsInPrerenderManager(url_b));
+  EXPECT_FALSE(UrlIsPendingInPrerenderManager(url_b));
+}
+
 }  // namespace prerender