Make reprioritization IPC batch rather than per-request.

content/browser/loader/resource_scheduler.cc

Index: content/browser/loader/resource_scheduler.cc
diff --git a/content/browser/loader/resource_scheduler.cc b/content/browser/loader/resource_scheduler.cc
index ad67fa91cd5436e240b104b3b3b8a9747ae8553d..c086c6fba2b54c8f49e47abda073cbf2b8774a84 100644
--- a/content/browser/loader/resource_scheduler.cc
+++ b/content/browser/loader/resource_scheduler.cc
@@ -418,6 +418,37 @@ class ResourceScheduler::Client {
     }
   }
 
+  void ReprioritizeRequests(
+      const std::vector<std::pair<ScheduledResourceRequest*,
+                                  RequestPriorityParams>>& change_requests) {
+    bool do_load = false;
+
+    for (auto& change_request : change_requests) {
+      ScheduledResourceRequest* resource_request(change_request.first);
+      const RequestPriorityParams& priority_params(change_request.second);
+
+      bool is_queued = pending_requests_.IsQueued(resource_request);
+
+      do_load |= is_queued && (priority_params.priority >
+                               resource_request->url_request()->priority());
+
+      resource_request->url_request()->SetPriority(priority_params.priority);
+      resource_request->set_request_priority_params(priority_params);
+      SetRequestAttributes(resource_request,
+                           DetermineRequestAttributes(resource_request));
+
+      if (!is_queued)
+        continue;
+
+      pending_requests_.Erase(resource_request);
+      pending_requests_.Insert(resource_request);
+    }
+
+    // Check if any requests are now able to load at their new priorities.
+    if (do_load)
+      LoadAnyStartablePendingRequests();
+  }
+
  private:
   enum ShouldStartReqResult {
     DO_NOT_START_REQUEST_AND_STOP_SEARCHING,
@@ -916,6 +947,53 @@ void ResourceScheduler::ReprioritizeRequest(net::URLRequest* request,
                               new_priority_params);
 }
 
+void ResourceScheduler::ReprioritizeRequests(
+    const std::vector<PriorityChangeRequest>& change_requests) {
+  std::map<Client*, std::vector<
+    std::pair<ScheduledResourceRequest*, RequestPriorityParams> > >
+      client_requests;
+  for (auto& change_request : change_requests) {
+    if (change_request.request->load_flags() & net::LOAD_IGNORE_LIMITS) {
+      // Requests with the IGNORE_LIMITS flag must stay at MAXIMUM_PRIORITY.
+      continue;
+    }
+
+    auto* scheduled_resource_request =
+        ScheduledResourceRequest::ForRequest(change_request.request);
+
+    // Downloads don't use the resource scheduler.
+    if (!scheduled_resource_request) {
+      change_request.request->SetPriority(change_request.priority);
+      continue;
+    }
+
+    RequestPriorityParams new_priority_params(
+        change_request.priority, change_request.intra_priority);
+    RequestPriorityParams old_priority_params =
+        scheduled_resource_request->get_request_priority_params();
+
+    if (old_priority_params == new_priority_params)
+      continue;
+
+    ClientMap::iterator client_it =
+        client_map_.find(scheduled_resource_request->client_id());
+    if (client_it == client_map_.end()) {
+      // The client was likely deleted shortly before we received this IPC.
+      change_request.request->SetPriority(new_priority_params.priority);
+      scheduled_resource_request->set_request_priority_params(
+          new_priority_params);
+      continue;
+    }
+
+    client_requests[client_it->second].push_back(std::make_pair(
+        scheduled_resource_request, new_priority_params));
+  }
+
+  for (auto& client_entry : client_requests)
+    client_entry.first->ReprioritizeRequests(client_entry.second);
+}
+
+
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;