New link rel=prerender api, using WebKit::WebPrerenderingPlatform

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/string_util.h"
 #include "base/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browsing_data_remover.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_contents.h"
+#include "chrome/browser/prerender/prerender_link_manager.h"
+#include "chrome/browser/prerender/prerender_link_manager_factory.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
@@ skipping 186 matching lines @@
 
   virtual void DidStopLoading() OVERRIDE {
     PrerenderContents::DidStopLoading();
     ++number_of_loads_;
     if (ShouldRenderPrerenderedPageCorrectly(expected_final_status_) &&
         number_of_loads_ == expected_number_of_loads_) {
       MessageLoopForUI::current()->Quit();
     }
   }
 
-  virtual void AddPendingPrerender(Origin origin,
-                                   const GURL& url,
-                                   const content::Referrer& referrer) OVERRIDE {
-    PrerenderContents::AddPendingPrerender(origin, url, referrer);
+  virtual void AddPendingPrerender(const GURL& url,
+                                   const content::Referrer& referrer,
+                                   const gfx::Size& size) OVERRIDE {
+    PrerenderContents::AddPendingPrerender(url, referrer, size);
     if (expected_pending_prerenders_ > 0 &&
         pending_prerender_list()->size() == expected_pending_prerenders_) {
       MessageLoop::current()->Quit();
     }
   }
 
   virtual WebContents* CreateWebContents(
       content::SessionStorageNamespace* session_storage_namespace) OVERRIDE {
     WebContents* web_contents = PrerenderContents::CreateWebContents(
         session_storage_namespace);
@@ skipping 378 matching lines @@
     OpenDestURLWithJSImpl("MetaClick()");
 #else
     OpenDestURLWithJSImpl("CtrlClick()");
 #endif
   }
 
   void OpenDestURLViaWindowOpen() const {
     OpenDestURLWithJSImpl("WindowOpen()");
   }
 
+  void RemoveLinkElementsAndNavigate() const {
+    OpenDestURLWithJSImpl("RemoveLinkElementsAndNavigate()");
+  }
+
   void ClickToNextPageAfterPrerender(Browser* browser) {
     ui_test_utils::WindowedNotificationObserver new_page_observer(
         content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::NotificationService::AllSources());
     RenderViewHost* render_view_host =
         browser->GetSelectedWebContents()->GetRenderViewHost();
     render_view_host->ExecuteJavascriptInWebFrame(
         string16(),
         ASCIIToUTF16("ClickOpenLink()"));
     new_page_observer.Wait();
@@ skipping 83 matching lines @@
   }
 
   PrerenderManager* GetPrerenderManager() const {
     Profile* profile =
         current_browser()->GetSelectedTabContentsWrapper()->profile();
     PrerenderManager* prerender_manager =
         PrerenderManagerFactory::GetForProfile(profile);
     return prerender_manager;
   }
 
+  const PrerenderLinkManager* GetPrerenderLinkManager() const {
+    Profile* profile =
+        current_browser()->GetSelectedTabContentsWrapper()->profile();
+    PrerenderLinkManager* prerender_link_manager =
+        PrerenderLinkManagerFactory::GetForProfile(profile);
+    return prerender_link_manager;
+  }
+
+  bool IsEmptyPrerenderLinkManager() const {
+    return GetPrerenderLinkManager()->IsEmpty();
+  }
+
   // Returns length of |prerender_manager_|'s history, or -1 on failure.
   int GetHistoryLength() const {
     scoped_ptr<DictionaryValue> prerender_dict(
         static_cast<DictionaryValue*>(GetPrerenderManager()->GetAsValue()));
     if (!prerender_dict.get())
       return -1;
     ListValue* history_list;
     if (!prerender_dict->GetList("history", &history_list))
       return -1;
     return static_cast<int>(history_list->GetSize());
   }
 
 #if defined(ENABLE_SAFE_BROWSING)
   FakeSafeBrowsingService* GetSafeBrowsingService() {
     return safe_browsing_factory_->most_recent_service();
   }
 #endif
 
   TestPrerenderContents* GetPrerenderContents() const {
     return static_cast<TestPrerenderContents*>(
         GetPrerenderManager()->FindEntry(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";
     host_resolver()->AddRule(secondary_domain, "127.0.0.1");
     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);
   }
@@ skipping 40 matching lines @@
     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,
                               net::TestServer::kLocalhost,
                               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);
+    GURL loader_url = src_server->GetURL(replacement_path +
+                                         loader_query_and_fragment_);
 
     PrerenderManager* prerender_manager = GetPrerenderManager();
     ASSERT_TRUE(prerender_manager);
     prerender_manager->mutable_config().rate_limit_enabled = false;
     prerender_manager->mutable_config().https_allowed = true;
     ASSERT_TRUE(prerender_contents_factory_ == NULL);
     prerender_contents_factory_ =
         new WaitForLoadPrerenderContentsFactory(
             expected_number_of_loads,
             expected_final_status_queue,
             prerender_should_wait_for_ready_title);
     prerender_manager->SetPrerenderContentsFactory(
         prerender_contents_factory_);
     FinalStatus expected_final_status = expected_final_status_queue.front();
 
     // ui_test_utils::NavigateToURL uses its own observer and message loop.
     // Since the test needs to wait until the prerendered page has stopped
     // loading, rather than the page directly navigated to, need to
     // handle browser navigation directly.
     current_browser()->OpenURL(OpenURLParams(
-        src_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED,
+        loader_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED,
         false));
 
     ui_test_utils::RunMessageLoop();
 
     TestPrerenderContents* prerender_contents = GetPrerenderContents();
 
     if (ShouldRenderPrerenderedPageCorrectly(expected_final_status)) {
       ASSERT_TRUE(prerender_contents != NULL);
       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
 
@@ skipping 89 matching lines @@
   }
 
   WaitForLoadPrerenderContentsFactory* prerender_contents_factory_;
 #if defined(ENABLE_SAFE_BROWSING)
   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
 #endif
   GURL dest_url_;
   bool use_https_src_server_;
   bool call_javascript_;
   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);
   NavigateToDestURL();
+  ASSERT_TRUE(IsEmptyPrerenderLinkManager());
+}
+
+// TODO(gavinp): After https://bugs.webkit.org/show_bug.cgi?id=85005 lands,
+// enable this test.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       DISABLED_PrerenderPageRemovingLink) {
+  set_loader_path("files/prerender/prerender_loader_removing_links.html");
+  set_loader_query_and_fragment("?links_to_insert=1&links_to_remove=1");
+  PrerenderTestURL("files/prerender/prerender_page.html",
+                   FINAL_STATUS_CANCELLED, 1);
+  RemoveLinkElementsAndNavigate();
+  ASSERT_TRUE(IsEmptyPrerenderLinkManager());
+}
+
+// TODO(gavinp): After https://bugs.webkit.org/show_bug.cgi?id=85005 lands,
+// enable this test.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       DISABLED_PrerenderPageRemovingLinkWithTwoLinks) {
+  set_loader_path("files/prerender/prerender_loader_removing_links.html");
+  set_loader_query_and_fragment("?links_to_insert=2&links_to_remove=2");
+  PrerenderTestURL("files/prerender/prerender_page.html",
+                   FINAL_STATUS_CANCELLED, 1);
+  RemoveLinkElementsAndNavigate();
+  ASSERT_TRUE(IsEmptyPrerenderLinkManager());
+}
+
+// TODO(gavinp): After https://bugs.webkit.org/show_bug.cgi?id=85005 lands,
+// enable this test.
+IN_PROC_BROWSER_TEST_F(
+    PrerenderBrowserTest,
+    DISABLED_PrerenderPageRemovingLinkWithTwoLinksRemovingOne) {
+  set_loader_path("files/prerender/prerender_loader_removing_links.html");
+  set_loader_query_and_fragment("?links_to_insert=2&links_to_remove=1");
+  PrerenderTestURL("files/prerender/prerender_page.html",
+                   FINAL_STATUS_USED, 1);
+  RemoveLinkElementsAndNavigate();
 }
 
 // Checks that prerendering works in incognito mode.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderIncognito) {
   Profile* normal_profile = current_browser()->profile();
   ui_test_utils::OpenURLOffTheRecord(normal_profile, GURL("about:blank"));
   set_browser(BrowserList::FindBrowserWithProfile(
       normal_profile->GetOffTheRecordProfile()));
   // Increase memory expectations on the incognito PrerenderManager.
   IncreasePrerenderMemory();
@@ skipping 1182 matching lines @@
   WebContents* web_contents = browser()->GetSelectedWebContents();
   bool display_test_result = false;
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       web_contents->GetRenderViewHost(), L"",
       L"DidDisplayReallyPass()",
       &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 
 }  // namespace prerender