Make reprioritization IPC batch rather than per-request.

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 <stdint.h>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 400 matching lines @@
 
     pending_requests_.Erase(request);
     pending_requests_.Insert(request);
 
     if (new_priority_params.priority > old_priority_params.priority) {
       // Check if this request is now able to load at its new priority.
       LoadAnyStartablePendingRequests();
     }
   }
 
+  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,
     DO_NOT_START_REQUEST_AND_KEEP_SEARCHING,
     START_REQUEST,
   };
 
   void InsertInFlightRequest(ScheduledResourceRequest* request) {
     in_flight_requests_.insert(request);
     SetRequestAttributes(request, DetermineRequestAttributes(request));
@@ skipping 478 matching lines @@
     scheduled_resource_request->set_request_priority_params(
         new_priority_params);
     return;
   }
 
   Client* client = client_it->second;
   client->ReprioritizeRequest(scheduled_resource_request, old_priority_params,
                               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;
 }
 
 }  // namespace content