Pass DomContentLoaded event from prerenders to launching elements.

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/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 1053 matching lines @@
   // current_browser().
   WebContents* GetActiveWebContents() const {
     return current_browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   // Overload for a single expected final status
   scoped_ptr<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
+    return PrerenderTestURL(html_file,
+                            expected_final_status,
+                            expected_number_of_loads,
+                            expected_number_of_loads);
+  }
+
+  scoped_ptr<TestPrerender> PrerenderTestURL(
+      const std::string& html_file,
+      FinalStatus expected_final_status,
+      int expected_number_of_dom_content_loads,
+      int expected_number_of_loads) {
     GURL url = test_server()->GetURL(html_file);
     return PrerenderTestURL(url,
                             expected_final_status,
+                            expected_number_of_dom_content_loads,
                             expected_number_of_loads);
   }
 
   ScopedVector<TestPrerender> PrerenderTestURL(
       const std::string& html_file,
       const std::vector<FinalStatus>& expected_final_status_queue,
       int expected_number_of_loads) {
     GURL url = test_server()->GetURL(html_file);
     return PrerenderTestURLImpl(url,
                                 expected_final_status_queue,
+                                expected_number_of_loads,
                                 expected_number_of_loads);
   }
 
   scoped_ptr<TestPrerender> PrerenderTestURL(
       const GURL& url,
       FinalStatus expected_final_status,
       int expected_number_of_loads) {
+    return PrerenderTestURL(url,
+                            expected_final_status,
+                            expected_number_of_loads,
+                            expected_number_of_loads);
+  }
+
+  scoped_ptr<TestPrerender> PrerenderTestURL(
+      const GURL& url,
+      FinalStatus expected_final_status,
+      int expected_number_of_dom_content_loads,
+      int expected_number_of_loads) {
     std::vector<FinalStatus> expected_final_status_queue(
         1, expected_final_status);
     std::vector<TestPrerender*> prerenders;
     PrerenderTestURLImpl(url,
                          expected_final_status_queue,
+                         expected_number_of_dom_content_loads,
                          expected_number_of_loads).release(&prerenders);
     CHECK_EQ(1u, prerenders.size());
     return scoped_ptr<TestPrerender>(prerenders[0]);
   }
 
   void NavigateToDestURL() const {
     NavigateToDestURLWithDisposition(CURRENT_TAB, true);
   }
 
   // Opens the url in a new tab, with no opener.
@@ skipping 193 matching lines @@
         "window.domAutomationController.send("
             "receivedPrerenderLoadEvents[%d] || 0)", index);
 
     CHECK(content::ExecuteScriptAndExtractInt(
         GetActiveWebContents(),
         expression,
         &load_event_count));
     return load_event_count;
   }
 
+  int GetPrerenderDomContentLoadedEventCountForLinkNumber(int index) const {
+    int dom_content_loaded_event_count;
+    std::string expression = base::StringPrintf(
+        "window.domAutomationController.send("
+            "receivedPrerenderDomContentLoadedEvents[%d] || 0)", index);
+
+    CHECK(content::ExecuteScriptAndExtractInt(
+        GetActiveWebContents(),
+        expression,
+        &dom_content_loaded_event_count));
+    return dom_content_loaded_event_count;
+  }
+
   bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
     bool received_prerender_stopped;
     std::string expression = base::StringPrintf(
         "window.domAutomationController.send(Boolean("
             "receivedPrerenderStopEvents[%d]))", index);
 
     CHECK(content::ExecuteScriptAndExtractBool(
         GetActiveWebContents(),
         expression,
         &received_prerender_stopped));
@@ skipping 140 matching lines @@
  private:
   // TODO(davidben): Remove this altogether so the tests don't globally assume
   // only one prerender.
   TestPrerenderContents* GetPrerenderContents() const {
     return GetPrerenderContentsFor(dest_url_);
   }
 
   ScopedVector<TestPrerender> PrerenderTestURLImpl(
       const GURL& prerender_url,
       const std::vector<FinalStatus>& expected_final_status_queue,
+      int expected_number_of_dom_content_loads,
       int expected_number_of_loads) {
     dest_url_ = prerender_url;
 
     std::vector<net::SpawnedTestServer::StringPair> replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
     std::string replacement_path;
     CHECK(net::SpawnedTestServer::GetFilePathWithReplacements(
         loader_path_,
         replacement_text,
@@ skipping 44 matching lines @@
       if (call_javascript_) {
         // Check if page behaves as expected while in prerendered state.
         EXPECT_TRUE(DidPrerenderPass(prerender_contents->prerender_contents()));
       }
     }
 
     // Test that the referring page received the right start and load events.
     EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
     if (check_load_events_) {
       EXPECT_EQ(expected_number_of_loads, prerenders[0]->number_of_loads());
+      // expected_number_of_dom_content_loads can differ from
+      // expected_number_of_loads, when prerender aborts between
+      // 'DOMContentLoaded' and 'load'.
+      EXPECT_EQ(expected_number_of_dom_content_loads,
+                GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
       EXPECT_EQ(expected_number_of_loads,
                 GetPrerenderLoadEventCountForLinkNumber(0));
     }
     EXPECT_FALSE(HadPrerenderEventErrors());
 
     return prerenders.Pass();
   }
 
   void NavigateToURLImpl(const content::OpenURLParams& params,
                          bool expect_swap_to_succeed) const {
@@ skipping 64 matching lines @@
   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) {
   UMAHistogramHelper histograms;
 
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);

[davidben, 2014/02/11 17:04:33]

Maybe a manual assertion after this line to test the basic case.

[ksimbili, 2014/02/11 20:05:57]

Done.

   histograms.Fetch();
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
   histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 1);
 
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
@@ skipping 323 matching lines @@
                    1);
   NavigateToDestURL();
 }
 
 // Renders a page that contains a prerender link to a page that contains an
 // iframe with a source that requires http authentication. This should not
 // prerender successfully.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttpAuthentication) {
   PrerenderTestURL("files/prerender/prerender_http_auth_container.html",
                    FINAL_STATUS_AUTH_NEEDED,
+                   1,
                    0);
 }
 
 // Checks that client-issued redirects work with prerendering.
 // This version navigates to the page which issues the redirection, rather
 // than the final destination page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderClientRedirectNavigateToFirst) {
   PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
                    FINAL_STATUS_USED,
@@ skipping 132 matching lines @@
   std::string redirect_path = CreateClientRedirect(
       "/files/prerender/prerender_embedded_content.html");
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
   std::string replacement_path;
   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
       &replacement_path));
-  PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 2);
+  PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1, 2);
   EXPECT_FALSE(UrlIsInPrerenderManager(
       "files/prerender/prerender_embedded_content.html"));
   NavigateToDestURL();
 }
 
 // Checks that server-issued redirects work with prerendering.
 // This version navigates to the page which issues the redirection, rather
 // than the final destination page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderServerRedirectNavigateToFirst) {
@@ skipping 44 matching lines @@
   EXPECT_FALSE(UrlIsInPrerenderManager(
       "files/prerender/prerender_embedded_content.html"));
   NavigateToDestURL();
 }
 
 // Prerenders a page that contains an automatic download triggered through an
 // iframe. This should not prerender successfully.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadIframe) {
   PrerenderTestURL("files/prerender/prerender_download_iframe.html",
                    FINAL_STATUS_DOWNLOAD,
+                   1,
                    0);
 }
 
 // Prerenders a page that contains an automatic download triggered through
 // Javascript changing the window.location. This should not prerender
 // successfully
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadLocation) {
   PrerenderTestURL(CreateClientRedirect("files/download-test1.lib"),
                    FINAL_STATUS_DOWNLOAD,
                    1);
@@ skipping 47 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPopup) {
   PrerenderTestURL("files/prerender/prerender_popup.html",
                    FINAL_STATUS_CREATE_NEW_WINDOW,
                    0);
 }
 
 // Checks that registering a protocol handler causes cancellation.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRegisterProtocolHandler) {
   PrerenderTestURL("files/prerender/prerender_register_protocol_handler.html",
                    FINAL_STATUS_REGISTER_PROTOCOL_HANDLER,
+                   1,
                    0);
 }
 
 // Checks that renderers using excessive memory will be terminated.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
   ASSERT_TRUE(GetPrerenderManager());
   GetPrerenderManager()->mutable_config().max_bytes = 30 * 1024 * 1024;
   // The excessive memory kill may happen before or after the load event as it
   // happens asynchronously with IPC calls. Even if the test does not start
   // allocating until after load, the browser process might notice before the
@@ skipping 519 matching lines @@
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that we cancel correctly when window.print() is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPrint) {
   PrerenderTestURL("files/prerender/prerender_print.html",
                    FINAL_STATUS_WINDOW_PRINT,
+                   1,
                    0);
 }
 
 // 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, due to
 // window.opener.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderSameDomainWindowOpenerWindowOpen) {
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_WINDOW_OPENER,
@@ skipping 68 matching lines @@
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_image.html",
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
+                   1,
                    0);
 }
 
 // Checks that an SSL Client Certificate request that originates from an
 // iframe will cancel the prerendered page.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertIframe) {
   ProfileIOData::FromResourceContext(
       current_browser()->profile()->GetResourceContext())->
           set_client_cert_store_factory_for_testing(
               base::Bind(&CreateCertStore));
   net::SpawnedTestServer::SSLOptions ssl_options;
   ssl_options.request_client_certificate = true;
   net::SpawnedTestServer https_server(
       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
   ASSERT_TRUE(https_server.Start());
   GURL https_url = https_server.GetURL(
       "files/prerender/prerender_embedded_content.html");
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_iframe.html",
       replacement_text,
       &replacement_path));
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
+                   1,
                    0);
 }
 
 #if defined(FULL_SAFE_BROWSING)
 // Ensures that we do not prerender pages with a safe browsing
 // interstitial.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingTopLevel) {
   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       url, SB_THREAT_TYPE_URL_MALWARE);
@@ skipping 598 matching lines @@
   GURL image_url = test_server()->GetURL(
       CreateServerRedirect("invalidscheme://www.google.com/test.jpg"));
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
       "files/prerender/prerender_with_image.html",
       replacement_text,
       &replacement_path));
-  PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
+  PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 1, 0);
 }
 
 // Checks that chrome-extension subresource does not cancel the prerender.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
                        PrerenderKeepSubresourceExtensionScheme) {
   GURL image_url = GURL("chrome-extension://abcdefg/test.jpg");
   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
@@ skipping 119 matching lines @@
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredImage) {
   DisableJavascriptCalls();
   UMAHistogramHelper histograms;
 
   // The prerender will not completely load until after the swap, so wait for a
   // title change before calling DidPrerenderPass.
   scoped_ptr<TestPrerender> prerender =
       PrerenderTestURL(
           "files/prerender/prerender_deferred_image.html",
           FINAL_STATUS_USED, 0);
   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);

[davidben, 2014/02/11 17:04:33]

This would be a pretty good place to assert DOMContentLoaded. This test is one
where, before the swap, DOMContentLoaded will eventually run, but load will
never run before the swap. So after the WaitForASCIITitle, assert that you've
gotten one webkitprerenderdomcontentloaded event.

Strictly speaking, image2 in prerender_deferred_image.html and the DOM parse
aren't ordered either. Maybe add a WaitForDOMContentLoads() to mirror
WaitForLoads in TestPrerender to be safe? Though I would be kinda surprised if
that one flaked.

I'm working on a CL as part of fixing some tests that'll let us wait on the
loader receiving the events which is probably closer to what we want anyway, but
that's not uploaded yet...

[ksimbili, 2014/02/11 20:05:57]

Added test here. I'll add WaitForDomContentLoads, if this is flaky.

   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
   EXPECT_EQ(0, prerender->number_of_loads());
   histograms.Fetch();
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
   histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
   histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 0);
 
   // Swap.
   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
@@ skipping 375 matching lines @@
   }
 };
 
 // Checks that prerendering works in incognito mode.
 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender