Handle interface to prerenders.

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_helper.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_handle.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_commands.h"
@@ skipping 73 matching lines @@
   prerender_manager->CancelAllPrerenders();
 }
 
 // Returns true if and only if the final status is one in which the prerendered
 // page should prerender correctly. The page still may not be used.
 bool ShouldRenderPrerenderedPageCorrectly(FinalStatus status) {
   switch (status) {
     case FINAL_STATUS_USED:
     case FINAL_STATUS_WINDOW_OPENER:
     case FINAL_STATUS_APP_TERMINATING:
-    case FINAL_STATUS_FRAGMENT_MISMATCH:
     case FINAL_STATUS_CACHE_OR_HISTORY_CLEARED:
     // We'll crash the renderer after it's loaded.
     case FINAL_STATUS_RENDERER_CRASHED:
     case FINAL_STATUS_CANCELLED:
     case FINAL_STATUS_DEVTOOLS_ATTACHED:
-    case FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH:
       return true;
     default:
       return false;
   }
 }
 
 // PrerenderContents that stops the UI message loop on DidStopLoading().
 class TestPrerenderContents : public PrerenderContents {
  public:
+  using PrerenderContents::PendingPrerenderInfo;

[dominich, 2012/06/28 00:34:32]

Do you really need these as a derived class of PrerenderContents? I thought
they'd be in scope.

[gavinp, 2012/07/02 18:19:29]

They are, but TestPrerenderManager calls them, and they are protected in
PrerenderContents.

+  using PrerenderContents::PendingPrerenderList;
+  using PrerenderContents::pending_prerender_list;
+
   TestPrerenderContents(
       PrerenderManager* prerender_manager,
       PrerenderTracker* prerender_tracker,
       Profile* profile,
       const GURL& url,
       const content::Referrer& referrer,
       int expected_number_of_loads,
       FinalStatus expected_final_status,
       bool prerender_should_wait_for_ready_title)
       : PrerenderContents(prerender_manager, prerender_tracker,
@@ skipping 80 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(const GURL& url,
-                                   const content::Referrer& referrer,
-                                   const gfx::Size& size) OVERRIDE {
-    PrerenderContents::AddPendingPrerender(url, referrer, size);
+  virtual PrerenderHandle AddPendingPrerender(const GURL& url,
+                                              const content::Referrer& referrer,
+                                              const gfx::Size& size) OVERRIDE {
+    PrerenderHandle handle =
+        PrerenderContents::AddPendingPrerender(url, referrer, size);
     if (expected_pending_prerenders_ > 0 &&
         pending_prerender_list()->size() == expected_pending_prerenders_) {
       MessageLoop::current()->Quit();
     }
+    return handle;
   }
 
   virtual WebContents* CreateWebContents(
       content::SessionStorageNamespace* session_storage_namespace) OVERRIDE {
     WebContents* web_contents = PrerenderContents::CreateWebContents(
         session_storage_namespace);
     string16 ready_title = ASCIIToUTF16(kReadyTitle);
     if (prerender_should_wait_for_ready_title_)
       ready_title_watcher_.reset(new ui_test_utils::TitleWatcher(
           web_contents, ready_title));
@@ skipping 19 matching lines @@
     EXPECT_EQ(expected_pending_prerenders, pending_prerender_list()->size());
   }
 
   // For tests that open the prerender in a new background tab, the RenderView
   // will not have been made visible when the PrerenderContents is destroyed
   // even though it is used.
   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 
   int number_of_loads() const { return number_of_loads_; }
 
+  FinalStatus expected_final_status() const { return expected_final_status_; }
+
  private:
   virtual void OnRenderViewHostCreated(
       RenderViewHost* new_render_view_host) OVERRIDE {
     // Used to make sure the RenderViewHost is hidden and, if used,
     // subsequently shown.
     notification_registrar().Add(
         this,
         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
         content::Source<RenderWidgetHost>(new_render_view_host));
 
@@ skipping 196 matching lines @@
 #endif
         use_https_src_server_(false),
         call_javascript_(true),
         loader_path_("files/prerender/prerender_loader.html"),
         explicitly_set_browser_(NULL) {
     EnableDOMAutomation();
   }
 
   virtual ~PrerenderBrowserTest() {}
 
+  content::SessionStorageNamespace* GetSessionStorageNamespace() const {
+    return current_browser()->GetActiveTabContents()->web_contents()->
+        GetRenderViewHost()->GetSessionStorageNamespace();
+  }
+
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
 #if defined(ENABLE_SAFE_BROWSING)
     SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
 #endif
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitchASCII(switches::kPrerenderMode,
                                     switches::kPrerenderModeSwitchValueEnabled);
 #if defined(OS_MACOSX)
@@ skipping 193 matching lines @@
         &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);
   }
 
   bool UrlIsInPrerenderManager(const std::string& html_file) const {
-    GURL dest_url = test_server()->GetURL(html_file);
-    return (GetPrerenderManager()->FindEntry(dest_url) != NULL);
+    return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
   }
 
-  bool UrlIsInPrerenderManager(const GURL& url) {
-    return (GetPrerenderManager()->FindEntry(url) != NULL);
+  bool UrlIsInPrerenderManager(const GURL& url) const {
+    return

[dominich, 2012/06/28 00:34:32]

nit:

return GetPrerenderManager()->FindEntry(
    url, GetSessionStorageNamespace()) != NULL;

+        GetPrerenderManager()->FindEntry(url,
+                                         GetSessionStorageNamespace()) != NULL;
   }
 
   bool UrlIsPendingInPrerenderManager(const std::string& html_file) const {
+    TestPrerenderContents* test_prerender_contents = GetPrerenderContents();
+    if (!test_prerender_contents)
+      return false;
     GURL dest_url = test_server()->GetURL(html_file);
-    return GetPrerenderManager()->IsPendingEntry(dest_url);
+    for (TestPrerenderContents::PendingPrerenderList::const_iterator
+             it = test_prerender_contents->pending_prerender_list()->begin(),
+             end = test_prerender_contents->pending_prerender_list()->end();
+         it != end;
+         ++it) {
+      if (it->url == dest_url) {
+        EXPECT_FALSE(GetPrerenderManager()->FindHandle(
+            dest_url, GetSessionStorageNamespace()));
+        EXPECT_TRUE(test_prerender_contents->IsPendingEntry(
+            it->prerender_handle_impl->AsWeakPtr()));
+        EXPECT_TRUE(it->prerender_handle_impl->IsPending());
+        return true;
+      }
+    }
+    return false;
   }
 
   void set_use_https_src(bool use_https_src_server) {
     use_https_src_server_ = use_https_src_server;
   }
 
   void DisableJavascriptCalls() {
     call_javascript_ = false;
   }
 
@@ skipping 32 matching lines @@
   }
 
 #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_));
+        GetPrerenderManager()->FindEntry(dest_url_,
+                                         GetSessionStorageNamespace()));
   }
 
   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;
   }
 
@@ skipping 96 matching lines @@
         bool prerender_test_result = false;
         ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
             prerender_contents->GetRenderViewHostMutable(), L"",
             L"window.domAutomationController.send(DidPrerenderPass())",
             &prerender_test_result));
         EXPECT_TRUE(prerender_test_result);
       }
     } else {
       // In the failure case, we should have removed |dest_url_| from the
       // prerender_manager.  We ignore dummy PrerenderContents (as indicated
-      // by not having started).
+      // 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());
+                  !prerender_contents->prerendering_has_started() ||
+                  prerender_contents->expected_final_status() ==
+                      FINAL_STATUS_MANAGER_SHUTDOWN);
     }
   }
 
   void NavigateToURLImpl(const GURL& dest_url,
                          WindowOpenDisposition disposition) const {
     ASSERT_TRUE(GetPrerenderManager() != NULL);
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_TRUE(GetPrerenderContents() != NULL);
 
     // If opening the page in a background tab, it won't be shown when swapped
@@ skipping 48 matching lines @@
       const {
     TestPrerenderContents* prerender_contents = GetPrerenderContents();
     ASSERT_TRUE(prerender_contents != NULL);
 
     RenderViewHost* render_view_host =
         current_browser()->GetActiveWebContents()->GetRenderViewHost();
     render_view_host->ExecuteJavascriptInWebFrame(
         string16(),
         ASCIIToUTF16(javascript_function_name));
 
-    // Run message loop until the prerender contents is destroyed.
-    ui_test_utils::RunMessageLoop();
+    if (prerender_contents->expected_final_status() !=
+        FINAL_STATUS_APP_TERMINATING) {
+      // Run message loop until the prerender contents is destroyed.
+      ui_test_utils::RunMessageLoop();
+    }
   }
 
   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_;
@@ skipping 659 matching lines @@
       LoadURL(
           GURL(chrome::kChromeUICrashURL),
           content::Referrer(),
           content::PAGE_TRANSITION_TYPED,
           std::string());
   ui_test_utils::RunMessageLoop();
 }
 
 // Checks that we correctly use a prerendered page when navigating to a
 // fragment.
 // DISABLED: http://crbug.com/84154

[dominich, 2012/06/28 00:34:32]

shouldn't be disabled any more?

 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        DISABLED_PrerenderPageNavigateFragment) {
   PrerenderTestURL("files/prerender/prerender_fragment.html",
-                   FINAL_STATUS_FRAGMENT_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   NavigateToURL("files/prerender/prerender_fragment.html#fragment");
 }
 
 // Checks that we correctly use a prerendered page when we prerender a fragment
 // but navigate to the main page.
 // http://crbug.com/83901
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,

[dominich, 2012/06/28 00:34:32]

shouldn't be disabled any more?

                        DISABLED_PrerenderFragmentNavigatePage) {
   PrerenderTestURL("files/prerender/prerender_fragment.html#fragment",
-                   FINAL_STATUS_FRAGMENT_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   NavigateToURL("files/prerender/prerender_fragment.html");
 }
 
 // Checks that we correctly use a prerendered page when we prerender a fragment
 // but navigate to a different fragment on the same page.
 // DISABLED: http://crbug.com/84154
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,

[dominich, 2012/06/28 00:34:32]

shouldn't be disabled any more?

                        DISABLED_PrerenderFragmentNavigateFragment) {
   PrerenderTestURL("files/prerender/prerender_fragment.html#other_fragment",
-                   FINAL_STATUS_FRAGMENT_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   NavigateToURL("files/prerender/prerender_fragment.html#fragment");
 }
 
 // Checks that we correctly use a prerendered page when the page uses a client
 // redirect to refresh from a fragment on the same page.
 // http://crbug.com/83901
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,

[dominich, 2012/06/28 00:34:32]

shouldn't be disabled any more?

                        DISABLED_PrerenderClientRedirectFromFragment) {
   PrerenderTestURL(
       CreateClientRedirect("files/prerender/prerender_fragment.html#fragment"),
-      FINAL_STATUS_FRAGMENT_MISMATCH,
+      FINAL_STATUS_APP_TERMINATING,
       2);
   NavigateToURL("files/prerender/prerender_fragment.html");
 }
 
 // Checks that we correctly use a prerendered page when the page uses a client
 // redirect to refresh to a fragment on the same page.
 // DISABLED: http://crbug.com/84154
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,

[dominich, 2012/06/28 00:34:32]

shouldn't be disabled any more?

                        DISABLED_PrerenderClientRedirectToFragment) {
   PrerenderTestURL(
       CreateClientRedirect("files/prerender/prerender_fragment.html"),
-      FINAL_STATUS_FRAGMENT_MISMATCH,
+      FINAL_STATUS_APP_TERMINATING,
       2);
   NavigateToURL("files/prerender/prerender_fragment.html#fragment");
 }
 
 // Checks that we correctly use a prerendered page when the page uses JS to set
 // the window.location.hash to a fragment on the same page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderPageChangeFragmentLocationHash) {
   PrerenderTestURL("files/prerender/prerender_fragment_location_hash.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToURL("files/prerender/prerender_fragment_location_hash.html");
 }
 
-// Checks that prerendering a PNG works correctly.
+// Checks that preren a PNG works correctly.

[dominich, 2012/06/28 00:34:32]

an accidental s/dering//g ?

 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImagePng) {
   DisableJavascriptCalls();
   PrerenderTestURL("files/prerender/image.png", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that prerendering a JPG works correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImageJpeg) {
   DisableJavascriptCalls();
   PrerenderTestURL("files/prerender/image.jpeg", FINAL_STATUS_USED, 1);
@@ skipping 126 matching lines @@
   PrerenderTestURL("files/prerender/prerender_print.html",
                    FINAL_STATUS_WINDOW_PRINT,
                    1);
 }
 
 // Checks that if a page is opened in a new window by javascript and both the
 // pages are in the same domain, the prerendered page is not used.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSameDomainWindowOpenerWindowOpen) {
   PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_WINDOW_OPENER,
+                   FINAL_STATUS_APP_TERMINATING,

[dominich, 2012/06/28 00:34:32]

this is surprising. we still want to cancel on WINDOW_OPENER, no?

                    1);
   OpenDestURLViaWindowOpen();
 }
 
 // Checks that if a page is opened due to click on a href with target="_blank"
 // and both pages are in the same domain the prerendered page is not used.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSameDomainWindowOpenerClickTarget) {
   PrerenderTestURL("files/prerender/prerender_page.html",
-                   FINAL_STATUS_WINDOW_OPENER,
+                   FINAL_STATUS_APP_TERMINATING,

[dominich, 2012/06/28 00:34:32]

ditto

                    1);
   OpenDestURLViaClickTarget();
 }
 
 // Checks that a top-level page which would normally request an SSL client
 // certificate will never be seen since it's an https top-level resource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertTopLevel) {
   net::TestServer::HTTPSOptions https_options;
   https_options.request_client_certificate = true;
   net::TestServer https_server(https_options,
@@ skipping 262 matching lines @@
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
                    FINAL_STATUS_USED,
                    1);
   OpenDestURLViaClick();
   NavigateToNextPageAfterPrerender();
   GoBackToPrerender();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewWindow) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickNewWindow();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewForegroundTab) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickNewForegroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewBackgroundTab) {
   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
-                   FINAL_STATUS_SESSION_STORAGE_NAMESPACE_MISMATCH,
+                   FINAL_STATUS_APP_TERMINATING,
                    1);
   OpenDestURLViaClickNewBackgroundTab();
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        NavigateToPrerenderedPageWhenDevToolsAttached) {
   DisableJavascriptCalls();
   WebContents* web_contents = current_browser()->GetActiveWebContents();
   DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
       web_contents->GetRenderViewHost());
@@ skipping 84 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLReferrerPolicy) {
   set_use_https_src(true);
   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender