[Net] Assert that URLRequests with LOAD_IGNORE_LIMITS have MAXIMUM_PRIORITY

net/socket/client_socket_pool_base.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/socket/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 122 matching lines @@
     const CompletionCallback& callback,
     RequestPriority priority,
     bool ignore_limits,
     Flags flags,
     const BoundNetLog& net_log)
     : handle_(handle),
       callback_(callback),
       priority_(priority),
       ignore_limits_(ignore_limits),
       flags_(flags),
-      net_log_(net_log) {}
+      net_log_(net_log) {
+  if (ignore_limits_)
+    DCHECK_EQ(priority_, MAXIMUM_PRIORITY);
+}
 
 ClientSocketPoolBaseHelper::Request::~Request() {}
 
 ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
     HigherLayeredPool* pool,
     int max_sockets,
     int max_sockets_per_group,
     base::TimeDelta unused_idle_socket_timeout,
     base::TimeDelta used_idle_socket_timeout,
     ConnectJobFactory* connect_job_factory)
@@ skipping 970 matching lines @@
   while (IsStalled()) {
     // Closing a socket will result in calling back into |this| to use the freed
     // socket slot, so nothing else is needed.
     if (!CloseOneIdleConnectionInHigherLayeredPool())
       return;
   }
 }
 
 ClientSocketPoolBaseHelper::Group::Group()
     : unassigned_job_count_(0),
-      // The number of priorities is doubled since requests with
-      // |ignore_limits| are prioritized over other requests.
-      pending_requests_(2 * NUM_PRIORITIES),
+      pending_requests_(NUM_PRIORITIES),
       active_socket_count_(0) {}
 
 ClientSocketPoolBaseHelper::Group::~Group() {
   DCHECK_EQ(0u, unassigned_job_count_);
 }
 
 void ClientSocketPoolBaseHelper::Group::StartBackupJobTimer(
     const std::string& group_name,
     ClientSocketPoolBaseHelper* pool) {
   // Only allow one timer to run at a time.
@@ skipping 116 matching lines @@
        !pointer.is_null() && i < jobs_.size();
        pointer = pending_requests_.GetNextTowardsLastMin(pointer), ++i) {
     if (pointer.value()->handle() == handle)
       return true;
   }
   return false;
 }
 
 void ClientSocketPoolBaseHelper::Group::InsertPendingRequest(
     scoped_ptr<const Request> request) {
-  RequestQueue::Priority queue_priority = request->priority();
-  // Prioritize requests with |ignore_limits| over ones that don't.
-  if (request->ignore_limits())
-    queue_priority += NUM_PRIORITIES;
-  pending_requests_.Insert(request.release(), queue_priority);
+  // We must cache this value before we release |request|.

[mmenke, 2013/11/01 19:06:39]

nit:  --We

[akalin, 2013/11/01 23:15:51]

Done.

+  RequestPriority priority = request->priority();
+  if (request->ignore_limits()) {
+    // Put requests with ignore_limits == true (which should have
+    // priority == MAXIMUM_PRIORITY) ahead of other requests with
+    // MAXIMUM_PRIORITY.
+    DCHECK_EQ(priority, MAXIMUM_PRIORITY);
+    pending_requests_.InsertAtFront(request.release(), priority);
+  } else {
+    pending_requests_.Insert(request.release(), priority);
+  }
 }
 
 scoped_ptr<const ClientSocketPoolBaseHelper::Request>
 ClientSocketPoolBaseHelper::Group::PopNextPendingRequest() {
   if (pending_requests_.empty())
     return scoped_ptr<const ClientSocketPoolBaseHelper::Request>();
   return RemovePendingRequest(pending_requests_.FirstMax());
 }
 
 scoped_ptr<const ClientSocketPoolBaseHelper::Request>
@@ skipping 17 matching lines @@
   pending_requests_.Erase(pointer);
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   return request.Pass();
 }
 
 }  // namespace internal
 
 }  // namespace net