Revert of [Prerender] Restore request priorities when swapped in

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 <stddef.h>
 #include <deque>
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ skipping 125 matching lines @@
 using content::Referrer;
 using content::RenderFrameHost;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::TestNavigationObserver;
 using content::WebContents;
 using content::WebContentsObserver;
 using net::NetworkChangeNotifier;
 using prerender::test_utils::RequestCounter;
 using prerender::test_utils::CreateCountingInterceptorOnIO;
-using prerender::test_utils::CreateHangingFirstRequestInterceptor;
+using prerender::test_utils::CreateHangingFirstRequestInterceptorOnIO;
 using prerender::test_utils::CreateMockInterceptorOnIO;
 using prerender::test_utils::TestPrerender;
 using prerender::test_utils::TestPrerenderContents;
 using task_manager::browsertest_util::WaitForTaskManagerRows;
 
 // crbug.com/708158
 #if !defined(OS_MACOSX) || !defined(ADDRESS_SANITIZER)
 
 // Prerender tests work as follows:
 //
 // A page with a prefetch link to the test page is loaded.  Once prerendered,
 // its Javascript function DidPrerenderPass() is called, which returns true if
 // the page behaves as expected when prerendered.
 //
 // The prerendered page is then displayed on a tab.  The Javascript function
 // DidDisplayPass() is called, and returns true if the page behaved as it
 // should while being displayed.
 
 namespace prerender {
 
 namespace {
 
-const char kPrefetchJpeg[] = "/prerender/image.jpeg";
-
 class FaviconUpdateWatcher : public favicon::FaviconDriverObserver {
  public:
   explicit FaviconUpdateWatcher(content::WebContents* web_contents)
       : seen_(false), running_(false), scoped_observer_(this) {
     scoped_observer_.Add(
         favicon::ContentFaviconDriver::FromWebContents(web_contents));
   }
 
   void Wait() {
     if (seen_)
@@ skipping 353 matching lines @@
       base::FilePath(FILE_PATH_LITERAL("prerender")),
       base::FilePath().AppendASCII(file_name));
 }
 
 page_load_metrics::PageLoadExtraInfo GenericPageLoadExtraInfo(
     const GURL& dest_url) {
   return page_load_metrics::PageLoadExtraInfo::CreateForTesting(
       dest_url, false /* started_in_foreground */);
 }
 
-// Helper function, to allow passing a UI closure to
-// CreateHangingFirstRequestInterceptor() instead of a IO callback.
-base::Callback<void(net::URLRequest*)> GetIOCallbackFromUIClosure(
-    base::Closure ui_closure) {
-  auto lambda = [](base::Closure closure, net::URLRequest*) {
-    content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-                                     closure);
-  };
-  return base::Bind(lambda, ui_closure);
-}
-
 }  // namespace
 
 class PrerenderBrowserTest : public test_utils::PrerenderInProcessBrowserTest {
  public:
   PrerenderBrowserTest()
       : call_javascript_(true),
         check_load_events_(true),
         loader_path_("/prerender/prerender_loader.html") {}
 
   ~PrerenderBrowserTest() override {}
@@ skipping 743 matching lines @@
 #define MAYBE_PrerenderNoCommitNoSwap PrerenderNoCommitNoSwap
 #endif
 // Checks that the prerendering of a page is canceled correctly if we try to
 // swap it in before it commits.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MAYBE_PrerenderNoCommitNoSwap) {
   // Navigate to a page that triggers a prerender for a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(GetTestPath("prerender_page.html"));
 
   base::RunLoop prerender_start_loop;
-  CreateHangingFirstRequestInterceptor(
-      kNoCommitUrl, file,
-      GetIOCallbackFromUIClosure(prerender_start_loop.QuitClosure()));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
+                 prerender_start_loop.QuitClosure()));
   DisableJavascriptCalls();
   PrerenderTestURL(kNoCommitUrl,
                    FINAL_STATUS_NAVIGATION_UNCOMMITTED,
                    0);
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigate to the URL, but assume the contents won't be swapped in.
   NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
 }
 
 // crbug.com/708158
 #if defined(OS_MACOSX) && defined(ADDRESS_SANITIZER)
 #define MAYBE_PrerenderNoCommitNoSwap2 DISABLED_PrerenderNoCommitNoSwap2
 #else
 #define MAYBE_PrerenderNoCommitNoSwap2 PrerenderNoCommitNoSwap2
 #endif
 // Checks that client redirects don't add alias URLs until after they commit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MAYBE_PrerenderNoCommitNoSwap2) {
   // Navigate to a page that then navigates to a URL that never commits.
   const GURL kNoCommitUrl("http://never-respond.example.com");
   base::FilePath file(GetTestPath("prerender_page.html"));
 
   base::RunLoop prerender_start_loop;
-  CreateHangingFirstRequestInterceptor(
-      kNoCommitUrl, file,
-      GetIOCallbackFromUIClosure(prerender_start_loop.QuitClosure()));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
+                 prerender_start_loop.QuitClosure()));
   DisableJavascriptCalls();
   PrerenderTestURL(CreateClientRedirect(kNoCommitUrl.spec()),
                    FINAL_STATUS_APP_TERMINATING, 1);
   // Wait for the hanging request to be scheduled.
   prerender_start_loop.Run();
 
   // Navigating to the second URL should not swap.
   NavigateToURLWithDisposition(kNoCommitUrl, WindowOpenDisposition::CURRENT_TAB,
                                false);
 }
@@ skipping 755 matching lines @@
 // Checks that prerendering a PNG works correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImagePng) {
   DisableJavascriptCalls();
   PrerenderTestURL("/prerender/image.png", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that prerendering a JPG works correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImageJpeg) {
   DisableJavascriptCalls();
-  PrerenderTestURL(kPrefetchJpeg, FINAL_STATUS_USED, 1);
+  PrerenderTestURL("/prerender/image.jpeg", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 // Checks that a prerender of a CRX will result in a cancellation due to
 // download.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCrx) {
   PrerenderTestURL("/prerender/extension.crx", FINAL_STATUS_DOWNLOAD, 0);
 }
 
 // Checks that xhr GET requests allow prerenders.
@@ skipping 51 matching lines @@
 }
 
 // Checks that an SSL error that comes from a subresource does not cancel
 // the page. Non-main-frame requests are simply cancelled if they run into
 // an SSL problem.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorSubresource) {
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_MISMATCHED_NAME);
   https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL(kPrefetchJpeg);
+  GURL https_url = https_server.GetURL("/prerender/image.jpeg");
   base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
   net::test_server::GetFilePathWithReplacements(
       "/prerender/prerender_with_image.html", replacement_text,
       &replacement_path);
   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
@@ skipping 91 matching lines @@
       ->set_client_cert_store_factory_for_testing(base::Bind(
           &CreateCertStore, net::ImportCertFromFile(
                                 net::GetTestCertsDirectory(), "ok_cert.pem")));
   net::EmbeddedTestServer https_server(net::EmbeddedTestServer::TYPE_HTTPS);
   net::SSLServerConfig ssl_config;
   ssl_config.client_cert_type =
       net::SSLServerConfig::ClientCertType::REQUIRE_CLIENT_CERT;
   https_server.SetSSLConfig(net::EmbeddedTestServer::CERT_OK, ssl_config);
   https_server.ServeFilesFromSourceDirectory("chrome/test/data");
   ASSERT_TRUE(https_server.Start());
-  GURL https_url = https_server.GetURL(kPrefetchJpeg);
+  GURL https_url = https_server.GetURL("/prerender/image.jpeg");
   base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
   std::string replacement_path;
   net::test_server::GetFilePathWithReplacements(
       "/prerender/prerender_with_image.html", replacement_text,
       &replacement_path);
   PrerenderTestURL(replacement_path,
                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
                    0);
@@ skipping 53 matching lines @@
                        PrerenderSafeBrowsingClientRedirect) {
   GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   PrerenderTestURL(CreateClientRedirect("/prerender/prerender_page.html"),
                    FINAL_STATUS_SAFE_BROWSING, 1);
 }
 
 // Ensures that we do not prerender pages which have a malware subresource.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingSubresource) {
-  GURL image_url = embedded_test_server()->GetURL(kPrefetchJpeg);
+  GURL image_url = embedded_test_server()->GetURL("/prerender/image.jpeg");
   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
       image_url, safe_browsing::SB_THREAT_TYPE_URL_MALWARE);
   base::StringPairs replacement_text;
   replacement_text.push_back(
       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
   std::string replacement_path;
   net::test_server::GetFilePathWithReplacements(
       "/prerender/prerender_with_image.html", replacement_text,
       &replacement_path);
   PrerenderTestURL(replacement_path,
@@ skipping 103 matching lines @@
   destruction_observer.Wait();
 }
 
 // Checks that a hanging unload on the referring page of a prerender swap does
 // not crash the browser on exit.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHangingUnload) {
   // Matches URL in prerender_loader_with_unload.html.
   const GURL hang_url("http://unload-url.test");
   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
-  CreateHangingFirstRequestInterceptor(
-      hang_url, empty_file, base::Callback<void(net::URLRequest*)>());
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO,
+                 hang_url, empty_file,
+                 base::Closure()));
 
   set_loader_path("/prerender/prerender_loader_with_unload.html");
   PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 
 // Checks that when the history is cleared, prerendering is cancelled and
 // prerendering history is cleared.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearHistory) {
@@ skipping 775 matching lines @@
                  done_url, empty_file, done_counter.AsWeakPtr()));
   // Loading may finish or be interrupted. The final result is important only.
   DisableLoadEventCheck();
   // TestPrenderContents is always created before the Autosignin JS can run, so
   // waiting for PrerenderContents to stop should be reliable.
   PrerenderTestURL("/password/autosignin.html",
                    FINAL_STATUS_CREDENTIAL_MANAGER_API, 0);
   EXPECT_EQ(0, done_counter.count());
 }
 
-// Checks that the requests from a prerender are IDLE priority before the swap
-// (except on Android), but normal priority after the swap.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ResourcePriority) {
-  GURL before_swap_url = embedded_test_server()->GetURL(kPrefetchJpeg);
-  GURL after_swap_url = embedded_test_server()->GetURL("/prerender/image.png");
-  GURL main_page_url =
-      GetURLWithReplacement("/prerender/prerender_with_image.html",
-                            "REPLACE_WITH_IMAGE_URL", kPrefetchJpeg);
-
-  // Setup request interceptors for subresources.
-  auto get_priority_lambda = [](net::RequestPriority* out_priority,
-                                net::URLRequest* request) {
-    *out_priority = request->priority();
-  };
-  RequestCounter before_swap_counter;
-  net::RequestPriority before_swap_priority = net::THROTTLED;
-  InterceptRequestAndCount(
-      before_swap_url, &before_swap_counter,
-      base::Bind(get_priority_lambda, base::Unretained(&before_swap_priority)));
-  RequestCounter after_swap_counter;
-  net::RequestPriority after_swap_priority = net::THROTTLED;
-  InterceptRequestAndCount(
-      after_swap_url, &after_swap_counter,
-      base::Bind(get_priority_lambda, base::Unretained(&after_swap_priority)));
-
-  // Start the prerender.
-  PrerenderTestURL(main_page_url, FINAL_STATUS_USED, 1);
-
-  // Check priority before swap.
-  before_swap_counter.WaitForCount(1);
-#if defined(OS_ANDROID)
-  EXPECT_GT(before_swap_priority, net::IDLE);
-#else
-  EXPECT_EQ(net::IDLE, before_swap_priority);
-#endif
-
-  // Swap.
-  NavigateToDestURL();
-
-  // Check priority after swap.
-  GetActiveWebContents()->GetMainFrame()->ExecuteJavaScriptForTests(
-      base::ASCIIToUTF16(
-          "var img=new Image(); img.src='/prerender/image.png'"));
-  after_swap_counter.WaitForCount(1);
-  EXPECT_NE(net::IDLE, after_swap_priority);
-}
-
-// Checks that a request started before the swap gets its original priority back
-// after the swap.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ResourcePriorityOverlappingSwap) {
-  GURL image_url = embedded_test_server()->GetURL(kPrefetchJpeg);
-  GURL main_page_url =
-      GetURLWithReplacement("/prerender/prerender_with_image.html",
-                            "REPLACE_WITH_IMAGE_URL", kPrefetchJpeg);
-
-  // Setup request interceptors for subresources.
-  net::URLRequest* url_request = nullptr;
-  net::RequestPriority priority = net::THROTTLED;
-  base::RunLoop wait_loop;
-  auto io_lambda = [](net::URLRequest** out_request,
-                      net::RequestPriority* out_priority, base::Closure closure,
-                      net::URLRequest* request) {
-    if (out_request)
-      *out_request = request;
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
-        base::Bind(
-            [](net::RequestPriority priority,
-               net::RequestPriority* out_priority, base::Closure closure) {
-              *out_priority = priority;
-              closure.Run();
-            },
-            request->priority(), base::Unretained(out_priority), closure));
-  };
-
-  CreateHangingFirstRequestInterceptor(
-      image_url, base::FilePath(),
-      base::Bind(io_lambda, base::Unretained(&url_request),
-                 base::Unretained(&priority), wait_loop.QuitClosure()));
-
-  // The prerender will hang on the image resource, can't run the usual checks.
-  DisableLoadEventCheck();
-  DisableJavascriptCalls();
-  // Start the prerender.
-  PrerenderTestURL(main_page_url, FINAL_STATUS_USED, 0);
-
-// Check priority before swap.
-#if defined(OS_ANDROID)
-  if (priority <= net::IDLE)
-    wait_loop.Run();
-  EXPECT_GT(priority, net::IDLE);
-#else
-  if (priority != net::IDLE)
-    wait_loop.Run();
-  EXPECT_EQ(net::IDLE, priority);
-#endif
-
-  // Swap. Cannot use NavigateToDestURL, because it waits for the load to
-  // complete, but the resource is still hung.
-  current_browser()->OpenURL(content::OpenURLParams(
-      dest_url(), Referrer(), WindowOpenDisposition::CURRENT_TAB,
-      ui::PAGE_TRANSITION_TYPED, false));
-
-  // Check priority after swap. The test may timeout in case of failure.
-  priority = net::THROTTLED;
-  do {
-    base::RunLoop loop;
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(io_lambda, nullptr, base::Unretained(&priority),
-                   loop.QuitClosure(), base::Unretained(url_request)));
-    loop.Run();
-  } while (priority <= net::IDLE);
-  EXPECT_GT(priority, net::IDLE);
-}
-
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, FirstContentfulPaintTimingSimple) {
   GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
   base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
   PrerenderTestURL("/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
 
   base::TimeTicks load_start = clock->NowTicks();
   clock->Advance(base::TimeDelta::FromSeconds(1));
   NavigateToDestURL();
 
   PrerenderPageLoadMetricsObserver observer(GetPrerenderManager(),
@@ skipping 12 matching lines @@
   histogram_tester().ExpectUniqueSample(
       "Prerender.websame_PrefetchTTFCP.Warm.Cacheable.Visible", 1654, 1);
 }
 
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, FirstContentfulPaintTimingReuse) {
   GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
   base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
 
   GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   base::RunLoop hanging_request_waiter;
-  CreateHangingFirstRequestInterceptor(
-      url, GetTestPath("prerender_page.html"),
-      GetIOCallbackFromUIClosure(hanging_request_waiter.QuitClosure()));
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&CreateHangingFirstRequestInterceptorOnIO,
+                                     url, GetTestPath("prerender_page.html"),
+                                     hanging_request_waiter.QuitClosure()));
   // As this load will be canceled, it is not waited for, and hence no
   // javascript is executed.
   DisableJavascriptCalls();
   PrerenderTestURL(url, FINAL_STATUS_CANCELLED, 0);
   hanging_request_waiter.Run();
 
   // This prerender cancels and reuses the first.
   clock->Advance(base::TimeDelta::FromSeconds(1));
   base::TimeTicks load_start = clock->NowTicks();
   EnableJavascriptCalls();
@@ skipping 64 matching lines @@
                        FirstContentfulPaintTimingNoCommit) {
   GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
   base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
 
   GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   base::FilePath url_file = ui_test_utils::GetTestFilePath(
       base::FilePath(),
       base::FilePath(FILE_PATH_LITERAL("prerender/prerender_page.html")));
 
   base::RunLoop prerender_start_loop;
-  CreateHangingFirstRequestInterceptor(
-      url, url_file,
-      GetIOCallbackFromUIClosure(prerender_start_loop.QuitClosure()));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, url, url_file,
+                 prerender_start_loop.QuitClosure()));
   // As this load is uncommitted, it is not waited for, and hence no
   // javascript is executed.
   DisableJavascriptCalls();
   PrerenderTestURL(url, FINAL_STATUS_NAVIGATION_UNCOMMITTED, 0);
   prerender_start_loop.Run();
 
   clock->Advance(base::TimeDelta::FromSeconds(1));
   NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
 
   PrerenderPageLoadMetricsObserver observer(GetPrerenderManager(),
@@ skipping 96 matching lines @@
                        FirstContentfulPaintHiddenNoCommit) {
   GetPrerenderManager()->DisablePageLoadMetricsObserverForTesting();
   base::SimpleTestTickClock* clock = OverridePrerenderManagerTimeTicks();
 
   GURL url = embedded_test_server()->GetURL("/prerender/prerender_page.html");
   base::FilePath url_file = ui_test_utils::GetTestFilePath(
       base::FilePath(),
       base::FilePath(FILE_PATH_LITERAL("prerender/prerender_page.html")));
 
   base::RunLoop prerender_start_loop;
-  CreateHangingFirstRequestInterceptor(
-      url, url_file,
-      GetIOCallbackFromUIClosure(prerender_start_loop.QuitClosure()));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, url, url_file,
+                 prerender_start_loop.QuitClosure()));
   // As this load is uncommitted, it is not waited for, and hence no
   // javascript is executed.
   DisableJavascriptCalls();
   PrerenderTestURL(url, FINAL_STATUS_NAVIGATION_UNCOMMITTED, 0);
   prerender_start_loop.Run();
 
   clock->Advance(base::TimeDelta::FromSeconds(1));
   NavigateToDestURLWithDisposition(WindowOpenDisposition::CURRENT_TAB, false);
 
   PrerenderPageLoadMetricsObserver observer(GetPrerenderManager(),
@@ skipping 239 matching lines @@
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
                                                    "DidDisplayReallyPass()",
                                                    &display_test_result));
   ASSERT_TRUE(display_test_result);
 }
 #endif  // !defined(DISABLE_NACL)
 
 }  // namespace prerender
 
 #endif  // !defined(OS_MACOSX) || !defined(ADDRESS_SANITIZER)