[Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY

content/browser/loader/resource_scheduler.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 "content/browser/loader/resource_scheduler.h"
 
 #include "base/stl_util.h"
 #include "content/common/resource_messages.h"
 #include "content/browser/loader/resource_message_delegate.h"
 #include "content/public/browser/resource_controller.h"
@@ skipping 156 matching lines @@
     // 3. The tab is closed while a RequestResource IPC is in flight.
     unowned_requests_.insert(request.get());
     request->Start();
     return request.PassAs<ResourceThrottle>();
   }
 
   Client* client = it->second;
   if (ShouldStartRequest(request.get(), client)) {
     StartRequest(request.get(), client);
   } else {
-    client->pending_requests.Insert(request.get(), url_request->priority());
+    client->pending_requests.Insert(request.get(), url_request->GetPriority());
   }
   return request.PassAs<ResourceThrottle>();
 }
 
 void ResourceScheduler::RemoveRequest(ScheduledResourceRequest* request) {
   DCHECK(CalledOnValidThread());
   if (ContainsKey(unowned_requests_, request)) {
     unowned_requests_.erase(request);
     return;
   }
@@ skipping 78 matching lines @@
 }
 
 void ResourceScheduler::StartRequest(ScheduledResourceRequest* request,
                                      Client* client) {
   client->in_flight_requests.insert(request);
   request->Start();
 }
 
 void ResourceScheduler::ReprioritizeRequest(ScheduledResourceRequest* request,
                                             net::RequestPriority new_priority) {
-  net::RequestPriority old_priority = request->url_request()->priority();
+  net::RequestPriority old_priority = request->url_request()->GetPriority();
   DCHECK_NE(new_priority, old_priority);
   request->url_request()->SetPriority(new_priority);
   ClientMap::iterator client_it = client_map_.find(request->client_id());
   if (client_it == client_map_.end()) {
     // The client was likely deleted shortly before we received this IPC.
     return;
   }
 
   Client *client = client_it->second;
   if (!client->pending_requests.IsQueued(request)) {
     DCHECK(ContainsKey(client->in_flight_requests, request));
     // Request has already started.
     return;
   }
 
   client->pending_requests.Erase(request);
-  client->pending_requests.Insert(request, request->url_request()->priority());
+  client->pending_requests.Insert(request,
+                                  request->url_request()->GetPriority());
 
   if (new_priority > old_priority) {
     // Check if this request is now able to load at its new priority.
     LoadAnyStartablePendingRequests(client);
   }
 }
 
 void ResourceScheduler::LoadAnyStartablePendingRequests(Client* client) {
   while (!client->pending_requests.IsEmpty()) {
     ScheduledResourceRequest* request = client->pending_requests.FirstMax();
     if (ShouldStartRequest(request, client)) {
       client->pending_requests.Erase(request);
       StartRequest(request, client);
     } else {
       break;
     }
   }
 }
 
 size_t ResourceScheduler::GetNumDelayableRequestsInFlight(
     Client* client) const {
   size_t count = 0;
   for (RequestSet::iterator it = client->in_flight_requests.begin();
        it != client->in_flight_requests.end(); ++it) {
-    if ((*it)->url_request()->priority() < net::LOW) {
+    if ((*it)->url_request()->GetPriority() < net::LOW) {
       const net::HttpServerProperties& http_server_properties =
           *(*it)->url_request()->context()->http_server_properties();
       if (!http_server_properties.SupportsSpdy(
           net::HostPortPair::FromURL((*it)->url_request()->url()))) {
         ++count;
       }
     }
   }
   return count;
 }
@@ skipping 28 matching lines @@
 
   const net::HttpServerProperties& http_server_properties =
       *url_request.context()->http_server_properties();
 
   // TODO(willchan): We should really improve this algorithm as described in
   // crbug.com/164101. Also, theoretically we should not count a SPDY request
   // against the delayable requests limit.
   bool origin_supports_spdy = http_server_properties.SupportsSpdy(
       net::HostPortPair::FromURL(url_request.url()));
 
-  if (url_request.priority() >= net::LOW ||
+  if (url_request.GetPriority() >= net::LOW ||
       !ResourceRequestInfo::ForRequest(&url_request)->IsAsync() ||
       origin_supports_spdy) {
     return true;
   }
 
   size_t num_delayable_requests_in_flight =
       GetNumDelayableRequestsInFlight(client);
   if (num_delayable_requests_in_flight >= kMaxNumDelayableRequestsPerClient) {
     return false;
   }
 
   bool have_immediate_requests_in_flight =
       client->in_flight_requests.size() > num_delayable_requests_in_flight;
   if (have_immediate_requests_in_flight && !client->has_body &&
       num_delayable_requests_in_flight != 0) {
     return false;
   }
 
   return true;
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content