[Prerender] Move tests + remove dead code.

Bug: 898955
Change-Id: Id85bc95c44ad553911dacf731630b5750d4779e3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2290930
Commit-Queue: Mugdha Lakhani <nator@chromium.org>
Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Cr-Commit-Position: refs/heads/master@{#788561}

chrome/browser/prerender/prerender_browsertest.cc

@@ -30,10 +30,7 @@
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_restrictions.h"
-//#include "base/values.h"
 #include "build/build_config.h"
-//#include
-//"chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
@@ -376,8 +373,7 @@ class NewTabNavigationOrSwapObserver : public TabStripModelObserver,
 class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
  public:
   PrerenderBrowserTest()
-      : call_javascript_(true),
-        check_load_events_(true),
+      : check_load_events_(true),
         loader_path_("/prerender/prerender_loader.html") {}
 
   ~PrerenderBrowserTest() override {}
@@ -520,10 +516,6 @@ class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
     EXPECT_TRUE(original_prerender_page);
   }
 
-  void DisableJavascriptCalls() { call_javascript_ = false; }
-
-  void EnableJavascriptCalls() { call_javascript_ = true; }
-
   void DisableLoadEventCheck() { check_load_events_ = false; }
 
   const PrerenderLinkManager* GetPrerenderLinkManager() const {
@@ -614,14 +606,8 @@ class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
     return GetPrerenderLinkManager()->CountRunningPrerenders();
   }
 
-  void SetLoaderHostOverride(const std::string& host) {
-    loader_host_override_ = host;
-  }
-
   void set_loader_path(const std::string& path) { loader_path_ = path; }
 
-  void set_loader_query(const std::string& query) { loader_query_ = query; }
-
   GURL GetCrossDomainTestUrl(const std::string& path) {
     static const std::string secondary_domain = "www.foo.com";
     std::string url_str(base::StringPrintf(
@@ -712,11 +698,7 @@ class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
     dest_url_ = prerender_url;
 
     GURL loader_url = ServeLoaderURL(loader_path_, "REPLACE_WITH_PRERENDER_URL",
-                                     prerender_url, "&" + loader_query_);
-    GURL::Replacements loader_replacements;
-    if (!loader_host_override_.empty())
-      loader_replacements.SetHostStr(loader_host_override_);
-    loader_url = loader_url.ReplaceComponents(loader_replacements);
+                                     prerender_url, "");
 
     std::vector<std::unique_ptr<TestPrerender>> prerenders =
         NavigateWithPrerenders(loader_url, expected_final_status_queue);
@@ -742,11 +724,6 @@ class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
       CHECK(prerender_contents);
       EXPECT_EQ(FINAL_STATUS_UNKNOWN, prerender_contents->final_status());
       EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
-
-      if (call_javascript_) {
-        // Check if page behaves as expected while in prerendered state.
-        EXPECT_TRUE(DidPrerenderPass(prerender_contents->prerender_contents()));
-      }
     }
 
     // Test for proper event ordering.
@@ -775,8 +752,6 @@ class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
 
     if (web_contents && expect_swap_to_succeed) {
       EXPECT_EQ(web_contents, target_web_contents);
-      if (call_javascript_)
-        EXPECT_TRUE(DidDisplayPass(web_contents));
     }
   }
 
@@ -813,11 +788,8 @@ class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
   base::SimpleTestTickClock clock_;
 
   GURL dest_url_;
-  bool call_javascript_;
   bool check_load_events_;
-  std::string loader_host_override_;
   std::string loader_path_;
-  std::string loader_query_;
   base::test::ScopedFeatureList feature_list_;
   std::unique_ptr<content::URLLoaderInterceptor> interceptor_;
 };
@@ -879,14 +851,6 @@ IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
                    FINAL_STATUS_MEMORY_LIMIT_EXCEEDED, 0);
 }
 
-// Checks shutdown code while a prerender is active.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderQuickQuit) {
-  DisableJavascriptCalls();
-  DisableLoadEventCheck();
-  PrerenderTestURL("/prerender/prerender_page.html",
-                   FINAL_STATUS_APP_TERMINATING, 0);
-}
-
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerBeforePrerender) {
   const base::string16 any_prerender = MatchTaskManagerPrerender("*");
   const base::string16 any_tab = MatchTaskManagerTab("*");
@@ -956,41 +920,6 @@ IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerAfterPrerender) {
   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
 }
 
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
-  std::unique_ptr<TestPrerender> prerender = PrerenderTestURL(
-      "/prerender/prerender_page.html", FINAL_STATUS_CANCELLED, 1);
-
-  GetPrerenderManager()->CancelAllPrerenders();
-  prerender->WaitForStop();
-
-  EXPECT_FALSE(prerender->contents());
-}
-
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEvents) {
-  std::unique_ptr<TestPrerender> prerender = PrerenderTestURL(
-      "/prerender/prerender_page.html", FINAL_STATUS_CANCELLED, 1);
-
-  GetPrerenderManager()->CancelAllPrerenders();
-  prerender->WaitForStop();
-
-  WaitForPrerenderStartEventForLinkNumber(0);
-  WaitForPrerenderStopEventForLinkNumber(0);
-  EXPECT_FALSE(HadPrerenderEventErrors());
-}
-
-// Cancels the prerender of a page with its own prerender.  The second prerender
-// should never be started.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
-                       PrerenderCancelPrerenderWithPrerender) {
-  std::unique_ptr<TestPrerender> prerender = PrerenderTestURL(
-      "/prerender/prerender_infinite_a.html", FINAL_STATUS_CANCELLED, 1);
-
-  GetPrerenderManager()->CancelAllPrerenders();
-  prerender->WaitForStop();
-
-  EXPECT_FALSE(prerender->contents());
-}
-
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewWindow) {
   PrerenderTestURL("/prerender/prerender_page_with_link.html",
                    FINAL_STATUS_APP_TERMINATING, 1);

chrome/browser/prerender/prerender_nostate_prefetch_browsertest.cc

@@ -119,6 +119,7 @@ const char kPrefetchDownloadFile[] = "/download-test1.lib";
 const char kPrefetchSubresourceRedirectPage[] =
     "/prerender/prefetch_subresource_redirect.html";
 const char kServiceWorkerLoader[] = "/prerender/service_worker.html";
+const char kHungPrerenderPage[] = "/prerender/hung_prerender_page.html";
 
 class NoStatePrefetchBrowserTest
     : public test_utils::PrerenderInProcessBrowserTest {
@@ -176,22 +177,69 @@ class NoStatePrefetchBrowserTest
   // test server.
   std::unique_ptr<TestPrerender> PrefetchFromURL(
       const GURL& target_url,
-      FinalStatus expected_final_status) {
+      FinalStatus expected_final_status,
+      int expected_number_of_loads = 0) {
     GURL loader_url = ServeLoaderURL(
         kPrefetchLoaderPath, "REPLACE_WITH_PREFETCH_URL", target_url, "");
     std::vector<FinalStatus> expected_final_status_queue(1,
                                                          expected_final_status);
     std::vector<std::unique_ptr<TestPrerender>> prerenders =
         NavigateWithPrerenders(loader_url, expected_final_status_queue);
-    prerenders[0]->WaitForStop();
+    prerenders[0]->WaitForLoads(0);
+
+    // Ensure that the referring page receives the right start and load events.
+    WaitForPrerenderStartEventForLinkNumber(0);
+    if (check_load_events_) {
+      WaitForPrerenderEventCount(0, "webkitprerenderload",
+                                 expected_number_of_loads);
+    }
+
+    if (ShouldAbortPrerenderBeforeSwap(expected_final_status_queue.front())) {
+      // The prerender will abort on its own. Assert it does so correctly.
+      prerenders[0]->WaitForStop();
+      EXPECT_FALSE(prerenders[0]->contents());
+      WaitForPrerenderStopEventForLinkNumber(0);
+    } else {
+      // Otherwise, check that it prerendered correctly.
+      test_utils::TestPrerenderContents* prerender_contents =
+          prerenders[0]->contents();
+      if (prerender_contents) {
+        EXPECT_EQ(FINAL_STATUS_UNKNOWN, prerender_contents->final_status());
+        EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
+      }
+    }
+
+    // Test for proper event ordering.
+    EXPECT_FALSE(HadPrerenderEventErrors());
+
     return std::move(prerenders[0]);
   }
 
+  // Returns true if the prerender is expected to abort on its own, before
+  // attempting to swap it.
+  bool ShouldAbortPrerenderBeforeSwap(FinalStatus status) {
+    switch (status) {
+      case FINAL_STATUS_USED:
+      case FINAL_STATUS_APP_TERMINATING:
+      case FINAL_STATUS_PROFILE_DESTROYED:
+      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:
+        return false;
+      default:
+        return true;
+    }
+  }
+
+  void DisableLoadEventCheck() { check_load_events_ = false; }
+
   std::unique_ptr<TestPrerender> PrefetchFromFile(
       const std::string& html_file,
-      FinalStatus expected_final_status) {
-    return PrefetchFromURL(src_server()->GetURL(html_file),
-                           expected_final_status);
+      FinalStatus expected_final_status,
+      int expected_number_of_loads = 0) {
+    return PrefetchFromURL(src_server()->GetURL(MakeAbsolute(html_file)),
+                           expected_final_status, expected_number_of_loads);
   }
 
   // Returns length of |prerender_manager_|'s history, or SIZE_MAX on failure.
@@ -218,6 +266,69 @@ class NoStatePrefetchBrowserTest
     // BrowsingDataRemover deletes itself.
   }
 
+  // Synchronization note: The IPCs used to communicate DOM events back to the
+  // referring web page (see blink::mojom::PrerenderHandleClient) may race w/
+  // the IPCs used here to inject script. The WaitFor* variants should be used
+  // when an event was expected to happen or to happen soon.
+
+  int GetPrerenderEventCount(int index, const std::string& type) const {
+    int event_count;
+    std::string expression = base::StringPrintf(
+        "window.domAutomationController.send("
+        "    GetPrerenderEventCount(%d, '%s'))",
+        index, type.c_str());
+
+    CHECK(content::ExecuteScriptAndExtractInt(GetActiveWebContents(),
+                                              expression, &event_count));
+    return event_count;
+  }
+
+  bool DidReceivePrerenderStartEventForLinkNumber(int index) const {
+    return GetPrerenderEventCount(index, "webkitprerenderstart") > 0;
+  }
+
+  int GetPrerenderLoadEventCountForLinkNumber(int index) const {
+    return GetPrerenderEventCount(index, "webkitprerenderload");
+  }
+
+  bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
+    return GetPrerenderEventCount(index, "webkitprerenderstop") > 0;
+  }
+
+  void WaitForPrerenderEventCount(int index,
+                                  const std::string& type,
+                                  int count) const {
+    int dummy;
+    std::string expression = base::StringPrintf(
+        "WaitForPrerenderEventCount(%d, '%s', %d,"
+        "    window.domAutomationController.send.bind("
+        "        window.domAutomationController, 0))",
+        index, type.c_str(), count);
+
+    CHECK(content::ExecuteScriptAndExtractInt(GetActiveWebContents(),
+                                              expression, &dummy));
+    CHECK_EQ(0, dummy);
+  }
+
+  void WaitForPrerenderStartEventForLinkNumber(int index) const {
+    WaitForPrerenderEventCount(index, "webkitprerenderstart", 1);
+  }
+
+  void WaitForPrerenderStopEventForLinkNumber(int index) const {
+    WaitForPrerenderEventCount(index, "webkitprerenderstart", 1);
+  }
+
+  bool HadPrerenderEventErrors() const {
+    bool had_prerender_event_errors;
+    CHECK(content::ExecuteScriptAndExtractBool(
+        GetActiveWebContents(),
+        "window.domAutomationController.send(Boolean("
+        "    hadPrerenderEventErrors))",
+        &had_prerender_event_errors));
+    return had_prerender_event_errors;
+  }
+
+  bool check_load_events_ = true;
   base::SimpleTestTickClock clock_;
 
  private:
@@ -966,7 +1077,7 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest,
                        PrefetchRedirectUnsupportedScheme) {
   PrefetchFromFile(
       CreateServerRedirect("invalidscheme://www.google.com/test.html"),
-      FINAL_STATUS_UNSUPPORTED_SCHEME);
+      FINAL_STATUS_UNSUPPORTED_SCHEME, 1);
 }
 
 // Checks that a 302 redirect is followed.
@@ -1428,7 +1539,7 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchIncognitoBrowserTest,
 // Checks that when the history is cleared, NoStatePrefetch history is cleared.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, ClearHistory) {
   std::unique_ptr<TestPrerender> test_prerender = PrefetchFromFile(
-      "/prerender/prerender_page.html", FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+      kHungPrerenderPage, FINAL_STATUS_CACHE_OR_HISTORY_CLEARED);
 
   ClearBrowsingData(current_browser(),
                     ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY);
@@ -1442,15 +1553,49 @@ IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, ClearHistory) {
 // cleared.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, ClearCache) {
   std::unique_ptr<TestPrerender> prerender = PrefetchFromFile(
-      "/prerender/prerender_page.html", FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+      kHungPrerenderPage, FINAL_STATUS_CACHE_OR_HISTORY_CLEARED);
 
   ClearBrowsingData(current_browser(),
                     content::BrowsingDataRemover::DATA_TYPE_CACHE);
   prerender->WaitForStop();
 
   // Make sure prerender history was not cleared.  Not a vital behavior, but
-  // used to compare with PrerenderClearHistory test.
+  // used to compare with ClearHistory test.
   EXPECT_EQ(1U, GetHistoryLength());
 }
 
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, CancelAll) {
+  GURL url = src_server()->GetURL(kHungPrerenderPage);
+  std::unique_ptr<TestPrerender> prerender =
+      PrefetchFromURL(url, FINAL_STATUS_CANCELLED, 0);
+
+  GetPrerenderManager()->CancelAllPrerenders();
+  prerender->WaitForStop();
+
+  EXPECT_FALSE(prerender->contents());
+}
+
+// Cancels the prerender of a page with its own prerender.  The second prerender
+// should never be started.
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest,
+                       CancelPrerenderWithPrerender) {
+  GURL url = src_server()->GetURL("/prerender/prerender_infinite_a.html");
+
+  std::unique_ptr<TestPrerender> prerender =
+      PrefetchFromURL(url, FINAL_STATUS_CANCELLED);
+
+  GetPrerenderManager()->CancelAllPrerenders();
+  prerender->WaitForStop();
+
+  EXPECT_FALSE(prerender->contents());
+}
+
+// Checks shutdown code while a prerender is active.
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, PrerenderQuickQuit) {
+  DisableLoadEventCheck();
+  GURL url = src_server()->GetURL(kHungPrerenderPage);
+  std::unique_ptr<TestPrerender> prerender =
+      PrefetchFromURL(url, FINAL_STATUS_APP_TERMINATING);
+}
+
 }  // namespace prerender

chrome/test/data/prerender/hung_prerender_page.html

+<html>
+<!-- 
+This test checks to make sure that a prerendered page is loaded.
+-->
+<head>
+<title>Prerender Page</title>
+
+<script>
+var pageWasPrerendered = false;
+
+// function DidPrerenderPass() {
+//   pageWasPrerendered = true;
+//   return true;
+// }
+
+// Make sure DidPrerenderPass() was called first.  Otherwise, the page was
+// most likely reloaded instead of using the prerendered page.
+// function DidDisplayPass() {
+//   return pageWasPrerendered;
+// }
+</script>
+
+</head>
+<body>
+  Text that is necessary for a FirstContentfulPaint metric to be recorded.
+  <img src="/hung">
+</body>
+</html>

chrome/test/data/prerender/prefetch_loader.html

 <html>
 <head>
   <title>Prefetch Loader</title>
-  <link rel='prerender' href='REPLACE_WITH_PREFETCH_URL'/>
+  <script src="prerender_events_common.js"></script>
 </head>
-<body></body>
+<body>
+  <script>
+    var numLinksToInsert =
+        ExtractGetParameterBadlyAndInsecurely('links_to_insert', 1);
+    for (var i = 0; i < numLinksToInsert; ++i) {
+      AddPrerender('REPLACE_WITH_PREFETCH_URL', i);
+    }
+    </script>
+</body>
 </html>

chrome/test/data/prerender/prerender_infinite_a.html

@@ -16,5 +16,6 @@
   <body>
     <link rel="prerender" href="prerender_infinite_b.html">
     <a href="prerender_infinite_b.html">B</a>
+    <img src="/hung">
   </body>
 </html>

chrome/test/data/prerender/prerender_page.html

@@ -8,16 +8,16 @@ This test checks to make sure that a prerendered page is loaded.
 <script>
 var pageWasPrerendered = false;
 
-function DidPrerenderPass() {
-  pageWasPrerendered = true;
-  return true;
-}
+// function DidPrerenderPass() {
+//   pageWasPrerendered = true;
+//   return true;
+// }
 
 // Make sure DidPrerenderPass() was called first.  Otherwise, the page was
 // most likely reloaded instead of using the prerendered page.
-function DidDisplayPass() {
-  return pageWasPrerendered;
-}
+// function DidDisplayPass() {
+//   return pageWasPrerendered;
+// }
 </script>
 
 </head>