Prioritize which HTTP requests get a socket first by adding a priority level ...

net/base/client_socket_pool.cc

 // Copyright (c) 2006-2008 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/base/client_socket_pool.h"
 
 #include "base/message_loop.h"
 #include "net/base/client_socket.h"
 #include "net/base/client_socket_handle.h"
 #include "net/base/net_errors.h"
@@ skipping 23 matching lines @@
 }
 
 ClientSocketPool::~ClientSocketPool() {
   // Clean up any idle sockets.  Assert that we have no remaining active
   // sockets or pending requests.  They should have all been cleaned up prior
   // to the manager being destroyed.
   CloseIdleSockets();
   DCHECK(group_map_.empty());
 }
 
+// InsertRequestIntoQueue inserts the request into the queue based on
+// priority.  Highest priorities are closest to the front.  Older requests are
+// prioritized over requests of equal priority.
+//
+// static
+void ClientSocketPool::InsertRequestIntoQueue(const Request& r,
+                                              RequestQueue* pending_requests) {
+  RequestQueue::iterator it = pending_requests->begin();
+  while (it != pending_requests->end() && r.priority <= it->priority)
+    ++it;
+  pending_requests->insert(it, r);
+}
+
 int ClientSocketPool::RequestSocket(ClientSocketHandle* handle,
+                                    int priority,
                                     CompletionCallback* callback) {
   Group& group = group_map_[handle->group_name_];
 
   // Can we make another active socket now?
   if (group.active_socket_count == max_sockets_per_group_) {
     Request r;
     r.handle = handle;
     DCHECK(callback);
     r.callback = callback;
-    group.pending_requests.push_back(r);
+    r.priority = priority;
+    InsertRequestIntoQueue(r, &group.pending_requests);
     return ERR_IO_PENDING;
   }
 
   // OK, we are going to activate one.
   group.active_socket_count++;
 
   // Use idle sockets in LIFO order because they're more likely to be
   // still reusable.
   while (!group.idle_sockets.empty()) {
     IdleSocket idle_socket = group.idle_sockets.back();
@@ skipping 111 matching lines @@
     group.idle_sockets.push_back(idle_socket);
     IncrementIdleCount();
   } else {
     delete ptr;
   }
 
   // Process one pending request.
   if (!group.pending_requests.empty()) {
     Request r = group.pending_requests.front();
     group.pending_requests.pop_front();
-    int rv = RequestSocket(r.handle, NULL);
+    int rv = RequestSocket(r.handle, r.priority, NULL);
     DCHECK(rv == OK);
     r.callback->Run(rv);
     return;
   }
 
   // Delete group if no longer needed.
   if (group.active_socket_count == 0 && group.idle_sockets.empty()) {
     DCHECK(group.pending_requests.empty());
     group_map_.erase(i);
   }
 }
 
 }  // namespace net