NoStatePrefetch: Add a test to verify request priority

chrome/browser/prerender/prerender_nostate_prefetch_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 "base/command_line.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_split.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/history_test_utils.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/prerender/prerender_test_utils.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/base/escape.h"
+#include "net/base/load_flags.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/request_handler_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using prerender::test_utils::CreateCountingInterceptorOnIO;
-using prerender::test_utils::CreatePrefetchOnlyInterceptorOnIO;
 using prerender::test_utils::DestructionWaiter;
 using prerender::test_utils::RequestCounter;
 using prerender::test_utils::TestPrerender;
 
 namespace prerender {
 
 // These URLs used for test resources must be relative with the exception of
 // |kPrefetchLoaderPath|.
 const char kPrefetchImagePage[] = "prerender/prefetch_image.html";
 const char kPrefetchJpeg[] = "prerender/image.jpeg";
@@ skipping 32 matching lines @@
   }
 
   // As above, but specify the data path and URL separately.
   void CountRequestForUrl(const GURL& url,
                           const std::string& path_str,
                           RequestCounter* counter) {
     base::FilePath url_file = ui_test_utils::GetTestFilePath(
         base::FilePath(), base::FilePath::FromUTF8Unsafe(path_str));
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&CreateCountingInterceptorOnIO, url, url_file,
-                   counter->AsWeakPtr()));
+        base::Bind(&prerender::test_utils::CreateCountingInterceptorOnIO, url,
+                   url_file, counter->AsWeakPtr()));
   }
 
  protected:
   std::unique_ptr<TestPrerender> PrefetchFromURL(
       const GURL& target_url,
       FinalStatus expected_final_status) {
     GURL loader_url = ServeLoaderURL(
         kPrefetchLoaderPath, "REPLACE_WITH_PREFETCH_URL", target_url, "");
     std::vector<FinalStatus> expected_final_status_queue(1,
                                                          expected_final_status);
@@ skipping 31 matching lines @@
   script2_counter.WaitForCount(0);
 
   // Verify that the page load did not happen.
   test_prerender->WaitForLoads(0);
 }
 
 // Check that the LOAD_PREFETCH flag is set.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, PrefetchLoadFlag) {
   RequestCounter main_counter;
   RequestCounter script_counter;
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreatePrefetchOnlyInterceptorOnIO,
-                 src_server()->GetURL(MakeAbsolute(kPrefetchPage)),
-                 main_counter.AsWeakPtr()));
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreatePrefetchOnlyInterceptorOnIO,
-                 src_server()->GetURL(MakeAbsolute(kPrefetchScript)),
-                 script_counter.AsWeakPtr()));
+  auto verify_prefetch_only = base::Bind([](net::URLRequest* request) {
+    EXPECT_TRUE(request->load_flags() & net::LOAD_PREFETCH);
+  });
+
+  prerender::test_utils::InterceptRequestAndCount(
+      src_server()->GetURL(MakeAbsolute(kPrefetchPage)), &main_counter,
+      verify_prefetch_only);
+  prerender::test_utils::InterceptRequestAndCount(
+      src_server()->GetURL(MakeAbsolute(kPrefetchScript)), &script_counter,
+      verify_prefetch_only);
 
   std::unique_ptr<TestPrerender> test_prerender =
       PrefetchFromFile(kPrefetchPage, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
   main_counter.WaitForCount(1);
   script_counter.WaitForCount(1);
 
   // Verify that the page load did not happen.
   test_prerender->WaitForLoads(0);
 }
 
@@ skipping 137 matching lines @@
 
 // Checks that the load flags are set correctly for all resources in a 301
 // redirect chain.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, Prefetch301LoadFlags) {
   std::string redirect_path =
       "/server-redirect/?" +
       net::EscapeQueryParamValue(MakeAbsolute(kPrefetchPage), false);
   GURL redirect_url = src_server()->GetURL(redirect_path);
   GURL page_url = src_server()->GetURL(MakeAbsolute(kPrefetchPage));
   RequestCounter redirect_counter;
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreatePrefetchOnlyInterceptorOnIO, redirect_url,
-                 redirect_counter.AsWeakPtr()));
+  auto verify_prefetch_only = base::Bind([](net::URLRequest* request) {
+    EXPECT_TRUE(request->load_flags() & net::LOAD_PREFETCH);
+  });
+  prerender::test_utils::InterceptRequestAndCount(
+      redirect_url, &redirect_counter, verify_prefetch_only);
   RequestCounter page_counter;
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreatePrefetchOnlyInterceptorOnIO, page_url,
-                 page_counter.AsWeakPtr()));
+  prerender::test_utils::InterceptRequestAndCount(page_url, &page_counter,
+                                                  verify_prefetch_only);
   PrefetchFromFile(redirect_path, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
   redirect_counter.WaitForCount(1);
   page_counter.WaitForCount(1);
 }
 
 // Checks that a subresource 301 redirect is followed.
 IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest, Prefetch301Subresource) {
   RequestCounter script_counter;
   CountRequestFor(kPrefetchScript, &script_counter);
   PrefetchFromFile(kPrefetchSubresourceRedirectPage,
@@ skipping 166 matching lines @@
   EXPECT_TRUE(std::find(urls.begin(), urls.end(), navigated_url) != urls.end());
 
   // Check that the URL that was prefetched is not in history.
   EXPECT_TRUE(std::find(urls.begin(), urls.end(), prefetched_url) ==
               urls.end());
 
   // The loader URL is the remaining entry.
   EXPECT_EQ(2U, urls.size());
 }
 
+// Checks that prefetch requests have net::IDLE priority.
+// On Android requests from prerenders do not get downgraded priority.
+// See: https://crbug.com/652746.
+#if defined(OS_ANDROID)
+#define MAYBE_IssuesIdlePriorityRequests DISABLED_IssuesIdlePriorityRequests

[droger, 2016/12/01 10:57:00]

Should we keep the test enabled on Android, but check for the corresponding
priority?

[pasko, 2016/12/01 12:04:54]

Good idea. Done. PTAL.

Since to bind a lambda the lambda has to be captureless, the preprocessor
directives are very nested, sorry about that.

+#else
+#define MAYBE_IssuesIdlePriorityRequests IssuesIdlePriorityRequests
+#endif
+IN_PROC_BROWSER_TEST_F(NoStatePrefetchBrowserTest,
+                       MAYBE_IssuesIdlePriorityRequests) {
+  GURL script_url = src_server()->GetURL(MakeAbsolute(kPrefetchScript));
+  RequestCounter script_counter;
+  prerender::test_utils::InterceptRequestAndCount(
+      script_url, &script_counter, base::Bind([](net::URLRequest* request) {
+        EXPECT_EQ(net::IDLE, request->priority());
+      }));
+  PrefetchFromFile(kPrefetchPage, FINAL_STATUS_NOSTATE_PREFETCH_FINISHED);
+  script_counter.WaitForCount(1);
+}
+
 }  // namespace prerender