[Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 1745 matching lines @@
   base::RunLoop().Run();
   EXPECT_EQ("", d.data_received());
   EXPECT_EQ(1, default_network_delegate_.completed_requests());
 }
 
 // Make sure that SetPriority actually sets the URLRequest's priority
 // correctly, both before and after start.
 TEST_F(URLRequestTest, SetPriorityBasic) {
   TestDelegate d;
   URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
-  EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
+  EXPECT_EQ(DEFAULT_PRIORITY, req.GetPriority());
 
   req.SetPriority(LOW);
-  EXPECT_EQ(LOW, req.priority());
+  EXPECT_EQ(LOW, req.GetPriority());
 
   req.Start();
-  EXPECT_EQ(LOW, req.priority());
+  EXPECT_EQ(LOW, req.GetPriority());
 
   req.SetPriority(MEDIUM);
-  EXPECT_EQ(MEDIUM, req.priority());
+  EXPECT_EQ(MEDIUM, req.GetPriority());
 }
 
 // Make sure that URLRequest calls SetPriority on a job before calling
 // Start on it.
 TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) {
   TestDelegate d;
   URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
-  EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
+  EXPECT_EQ(DEFAULT_PRIORITY, req.GetPriority());
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(&req, &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
   EXPECT_EQ(DEFAULT_PRIORITY, job->priority());
 
   req.SetPriority(LOW);
 
   req.Start();
   EXPECT_EQ(LOW, job->priority());
 }
 
 // Make sure that URLRequest passes on its priority updates to its
 // job.
 TEST_F(URLRequestTest, SetJobPriority) {
   TestDelegate d;
   URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
 
   scoped_refptr<URLRequestTestJob> job =
       new URLRequestTestJob(&req, &default_network_delegate_);
   AddTestInterceptor()->set_main_intercept_job(job.get());
 
   req.SetPriority(LOW);
   req.Start();
   EXPECT_EQ(LOW, job->priority());
 
   req.SetPriority(MEDIUM);
-  EXPECT_EQ(MEDIUM, req.priority());
+  EXPECT_EQ(MEDIUM, req.GetPriority());
   EXPECT_EQ(MEDIUM, job->priority());
 }
 
+// Setting the IGNORE_LIMITS load flag should cause priority to become
+// MAXIMUM_PRIORITY, and unnsetting it should revert to the base
+// priority.
+TEST_F(URLRequestTest, PriorityIgnoreLimits) {
+  TestDelegate d;
+  URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_);
+  EXPECT_EQ(DEFAULT_PRIORITY, req.GetPriority());
+
+  scoped_refptr<URLRequestTestJob> job =
+      new URLRequestTestJob(&req, &default_network_delegate_);
+  AddTestInterceptor()->set_main_intercept_job(job.get());
+
+  req.SetLoadFlags(LOAD_IGNORE_LIMITS);
+  EXPECT_EQ(MAXIMUM_PRIORITY, req.GetPriority());
+
+  req.SetPriority(LOW);
+  EXPECT_EQ(MAXIMUM_PRIORITY, req.GetPriority());
+
+  req.SetLoadFlags(~LOAD_IGNORE_LIMITS);
+  EXPECT_EQ(LOW, req.GetPriority());
+
+  req.SetLoadFlags(LOAD_IGNORE_LIMITS);
+  EXPECT_EQ(MAXIMUM_PRIORITY, req.GetPriority());
+
+  req.Start();
+  EXPECT_EQ(MAXIMUM_PRIORITY, req.GetPriority());
+  EXPECT_EQ(MAXIMUM_PRIORITY, job->priority());
+
+  req.SetPriority(MEDIUM);
+  EXPECT_EQ(MAXIMUM_PRIORITY, req.GetPriority());
+  EXPECT_EQ(MAXIMUM_PRIORITY, job->priority());
+}
+
 // TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666).
 #if !defined(OS_IOS)
 // A subclass of SpawnedTestServer that uses a statically-configured hostname.
 // This is to work around mysterious failures in chrome_frame_net_tests. See:
 // http://crbug.com/114369
 class LocalHttpTestServer : public SpawnedTestServer {
  public:
   explicit LocalHttpTestServer(const base::FilePath& document_root)
       : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
                           ScopedCustomUrlRequestTestHttpHost::value(),
@@ skipping 78 matching lines @@
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
 
   // Verify that the cookie isn't sent when LOAD_DO_NOT_SEND_COOKIES is set.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(
         test_server.GetURL("echoheader?Cookie"), &d, &default_context_);
-    req.set_load_flags(LOAD_DO_NOT_SEND_COOKIES);
+    req.SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
     req.Start();
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
   }
@@ skipping 21 matching lines @@
 
   // Try to set-up another cookie and update the previous cookie.
   {
     TestNetworkDelegate network_delegate;
     default_context_.set_network_delegate(&network_delegate);
     TestDelegate d;
     URLRequest req(
         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
         &d,
         &default_context_);
-    req.set_load_flags(LOAD_DO_NOT_SAVE_COOKIES);
+    req.SetLoadFlags(LOAD_DO_NOT_SAVE_COOKIES);
     req.Start();
 
     base::RunLoop().Run();
 
     // LOAD_DO_NOT_SAVE_COOKIES does not trigger OnSetCookie.
     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
     EXPECT_EQ(0, network_delegate.set_cookie_count());
   }
 
@@ skipping 386 matching lines @@
   // If extra headers contain a referer but the request does not, no referer
   // shall be sent in the header.
   {
     TestDelegate d;
     URLRequest req(
         test_server.GetURL("echoheader?Referer"), &d, &default_context_);
 
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
     req.SetExtraRequestHeaders(headers);
-    req.set_load_flags(LOAD_VALIDATE_CACHE);
+    req.SetLoadFlags(LOAD_VALIDATE_CACHE);
 
     req.Start();
     base::RunLoop().Run();
 
     EXPECT_EQ("None", d.data_received());
   }
 }
 
 class URLRequestTestHTTP : public URLRequestTest {
  public:
@@ skipping 2700 matching lines @@
   }
 
   // repeat request with end-to-end validation.  since auth-basic results in a
   // cachable page, we expect this test to result in a 304.  in which case, the
   // response should be fetched from the cache.
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_);
-    r.set_load_flags(LOAD_VALIDATE_CACHE);
+    r.SetLoadFlags(LOAD_VALIDATE_CACHE);
     r.Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
     EXPECT_TRUE(r.was_cached());
   }
 }
@@ skipping 93 matching lines @@
   }
 
   // Repeat request with end-to-end validation.  Since auth-basic results in a
   // cachable page, we expect this test to result in a 304.  In which case, the
   // response should be fetched from the cache.
   {
     TestDelegate d;
     d.set_credentials(AuthCredentials(kUser, kSecret));
 
     URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_);
-    r.set_load_flags(LOAD_VALIDATE_CACHE);
+    r.SetLoadFlags(LOAD_VALIDATE_CACHE);
     r.Start();
 
     base::RunLoop().Run();
 
     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
 
     // Should be the same cached document.
     EXPECT_TRUE(r.was_cached());
 
     // Since there was a request that went over the wire, the load timing
@@ skipping 314 matching lines @@
   }
 }
 
 // Make sure that URLRequest passes on its priority updates to
 // newly-created jobs after the first one.
 TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_);
-  EXPECT_EQ(DEFAULT_PRIORITY, req.priority());
+  EXPECT_EQ(DEFAULT_PRIORITY, req.GetPriority());
 
   scoped_refptr<URLRequestRedirectJob> redirect_job =
       new URLRequestRedirectJob(
           &req, &default_network_delegate_, test_server_.GetURL("echo"),
           URLRequestRedirectJob::REDIRECT_302_FOUND);
   AddTestInterceptor()->set_main_intercept_job(redirect_job.get());
 
   req.SetPriority(LOW);
   req.Start();
   EXPECT_TRUE(req.is_pending());
@@ skipping 1423 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net