[Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY

net/url_request/url_request.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 "net/url_request/url_request.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 198 matching lines @@
       net_log_(BoundNetLog::Make(context->net_log(),
                                  NetLog::SOURCE_URL_REQUEST)),
       url_chain_(1, url),
       method_("GET"),
       referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       is_redirecting_(false),
       redirect_limit_(kMaxRedirects),
-      priority_(DEFAULT_PRIORITY),
+      base_priority_(DEFAULT_PRIORITY),
       identifier_(GenerateURLRequestIdentifier()),
       calling_delegate_(false),
       delegate_info_usage_(DELEGATE_INFO_DEBUG_ONLY),
       before_request_callback_(base::Bind(&URLRequest::BeforeRequestComplete,
                                           base::Unretained(this))),
       has_notified_completion_(false),
       received_response_content_length_(0),
       creation_time_(base::TimeTicks::Now()) {
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
@@ skipping 16 matching lines @@
       net_log_(BoundNetLog::Make(context->net_log(),
                                  NetLog::SOURCE_URL_REQUEST)),
       url_chain_(1, url),
       method_("GET"),
       referrer_policy_(CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE),
       load_flags_(LOAD_NORMAL),
       delegate_(delegate),
       is_pending_(false),
       is_redirecting_(false),
       redirect_limit_(kMaxRedirects),
-      priority_(DEFAULT_PRIORITY),
+      base_priority_(DEFAULT_PRIORITY),
       identifier_(GenerateURLRequestIdentifier()),
       calling_delegate_(false),
       delegate_info_usage_(DELEGATE_INFO_DEBUG_ONLY),
       before_request_callback_(base::Bind(&URLRequest::BeforeRequestComplete,
                                           base::Unretained(this))),
       has_notified_completion_(false),
       received_response_content_length_(0),
       creation_time_(base::TimeTicks::Now()) {
   SIMPLE_STATS_COUNTER("URLRequestCount");
 
@@ skipping 261 matching lines @@
 void URLRequest::GetCharset(string* charset) {
   DCHECK(job_.get());
   job_->GetCharset(charset);
 }
 
 int URLRequest::GetResponseCode() const {
   DCHECK(job_.get());
   return job_->GetResponseCode();
 }
 
+void URLRequest::SetLoadFlags(int flags) {
+  if ((load_flags_ & LOAD_IGNORE_LIMITS) != (flags & LOAD_IGNORE_LIMITS))
+    DCHECK(!job_);
+  load_flags_ = flags;
+}
+
 // static
 void URLRequest::SetDefaultCookiePolicyToBlock() {
   CHECK(!g_url_requests_started);
   g_default_can_use_cookies = false;
 }
 
 // static
 bool URLRequest::IsHandledProtocol(const std::string& scheme) {
   return URLRequestJobManager::GetInstance()->SupportsScheme(scheme);
 }
@@ skipping 127 matching lines @@
   }
 }
 
 void URLRequest::StartJob(URLRequestJob* job) {
   DCHECK(!is_pending_);
   DCHECK(!job_.get());
 
   net_log_.BeginEvent(
       NetLog::TYPE_URL_REQUEST_START_JOB,
       base::Bind(&NetLogURLRequestStartCallback,
-                 &url(), &method_, load_flags_, priority_,
+                 &url(), &method_, load_flags_, GetPriority(),
                  upload_data_stream_ ? upload_data_stream_->identifier() : -1));
 
   job_ = job;
   job_->SetExtraRequestHeaders(extra_request_headers_);
-  job_->SetPriority(priority_);
+  job_->SetPriority(GetPriority());
 
   if (upload_data_stream_.get())
     job_->SetUpload(upload_data_stream_.get());
 
   is_pending_ = true;
   is_redirecting_ = false;
 
   response_info_.was_cached = false;
 
   // Don't allow errors to be sent from within Start().
@@ skipping 286 matching lines @@
 }
 
 int64 URLRequest::GetExpectedContentSize() const {
   int64 expected_content_size = -1;
   if (job_.get())
     expected_content_size = job_->expected_content_size();
 
   return expected_content_size;
 }
 
+RequestPriority URLRequest::GetPriority() const {
+  return (load_flags_ & LOAD_IGNORE_LIMITS) ? MAXIMUM_PRIORITY : base_priority_;
+}
+
 void URLRequest::SetPriority(RequestPriority priority) {
   DCHECK_GE(priority, MINIMUM_PRIORITY);
   DCHECK_LE(priority, MAXIMUM_PRIORITY);
-  if (priority_ == priority)
+
+  RequestPriority old_priority = GetPriority();
+
+  base_priority_ = priority;
+
+  if (GetPriority() == old_priority)
     return;
 
-  priority_ = priority;
   if (job_.get()) {
     net_log_.AddEvent(NetLog::TYPE_URL_REQUEST_SET_PRIORITY,
-                      NetLog::IntegerCallback("priority", priority_));
-    job_->SetPriority(priority_);
+                      NetLog::IntegerCallback("priority", GetPriority()));
+    job_->SetPriority(GetPriority());
   }
 }
 
 bool URLRequest::GetHSTSRedirect(GURL* redirect_url) const {
   const GURL& url = this->url();
   if (!url.SchemeIs("http"))
     return false;
   TransportSecurityState::DomainState domain_state;
   if (context()->transport_security_state() &&
       context()->transport_security_state()->GetDomainState(
@@ skipping 178 matching lines @@
       new base::debug::StackTrace(NULL, 0);
   *stack_trace_copy = stack_trace;
   stack_trace_.reset(stack_trace_copy);
 }
 
 const base::debug::StackTrace* URLRequest::stack_trace() const {
   return stack_trace_.get();
 }
 
 }  // namespace net