[net/dns] Perform A/AAAA queries for AF_UNSPEC resolutions in parallel.

net/base/prioritized_dispatcher.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/base/prioritized_dispatcher.h"
 
 #include "base/logging.h"
 
 namespace net {
 
 PrioritizedDispatcher::Limits::Limits(Priority num_priorities,
                                       size_t total_jobs)
     : total_jobs(total_jobs), reserved_slots(num_priorities) {}
 
 PrioritizedDispatcher::Limits::~Limits() {}
 
 PrioritizedDispatcher::PrioritizedDispatcher(const Limits& limits)
     : queue_(limits.reserved_slots.size()),
       max_running_jobs_(limits.reserved_slots.size()),
       num_running_jobs_(0) {
-  size_t total = 0;
-  for (size_t i = 0; i < limits.reserved_slots.size(); ++i) {
-    total += limits.reserved_slots[i];
-    max_running_jobs_[i] = total;
-  }
-  // Unreserved slots are available for all priorities.
-  DCHECK_LE(total, limits.total_jobs) << "sum(reserved_slots) <= total_jobs";
-  size_t spare = limits.total_jobs - total;
-  for (size_t i = limits.reserved_slots.size(); i > 0; --i) {
-    max_running_jobs_[i - 1] += spare;
-  }
+  SetLimits(limits);
 }
 
 PrioritizedDispatcher::~PrioritizedDispatcher() {}
 
 PrioritizedDispatcher::Handle PrioritizedDispatcher::Add(
     Job* job, Priority priority) {
   DCHECK(job);
   DCHECK_LT(priority, num_priorities());
   if (num_running_jobs_ < max_running_jobs_[priority]) {
     ++num_running_jobs_;
     job->Start();
     return Handle();
   }
   return queue_.Insert(job, priority);
 }
 
+PrioritizedDispatcher::Handle PrioritizedDispatcher::AddAtHead(
+    Job* job, Priority priority) {
+  DCHECK(job);
+  DCHECK_LT(priority, num_priorities());
+  if (num_running_jobs_ < max_running_jobs_[priority]) {
+    ++num_running_jobs_;
+    job->Start();
+    return Handle();
+  }
+  return queue_.InsertAtFront(job, priority);
+}
+
 void PrioritizedDispatcher::Cancel(const Handle& handle) {
   queue_.Erase(handle);
 }
 
 PrioritizedDispatcher::Job* PrioritizedDispatcher::EvictOldestLowest() {
   Handle handle = queue_.FirstMin();
   if (handle.is_null())
     return NULL;
   Job* job = handle.value();
   Cancel(handle);
@@ skipping 21 matching lines @@
   DCHECK_GT(num_running_jobs_, 0u);
   --num_running_jobs_;
   Handle handle = queue_.FirstMax();
   if (handle.is_null()) {
     DCHECK_EQ(0u, queue_.size());
     return;
   }
   MaybeDispatchJob(handle, handle.priority());
 }
 
+void PrioritizedDispatcher::Disable() {
+  // Set limits to allow no new jobs to start.
+  SetLimits(Limits(queue_.NumPriorities(), 0));
+}
+
 bool PrioritizedDispatcher::MaybeDispatchJob(const Handle& handle,
                                              Priority job_priority) {
   DCHECK_LT(job_priority, num_priorities());
   if (num_running_jobs_ >= max_running_jobs_[job_priority])
     return false;
   Job* job = handle.value();
   queue_.Erase(handle);
   ++num_running_jobs_;
   job->Start();
   return true;
 }
 
+void PrioritizedDispatcher::SetLimits(const Limits& limits) {

[szym, 2013/08/20 16:24:57]

suggest adding
DCHECK_EQ(queue_.num_priorities(), limits.reserved_slots.size());

[mmenke, 2013/08/20 16:33:13]

SGTM.  Done.

+  size_t total = 0;
+  for (size_t i = 0; i < limits.reserved_slots.size(); ++i) {
+    total += limits.reserved_slots[i];
+    max_running_jobs_[i] = total;
+  }
+  // Unreserved slots are available for all priorities.
+  DCHECK_LE(total, limits.total_jobs) << "sum(reserved_slots) <= total_jobs";
+  size_t spare = limits.total_jobs - total;
+  for (size_t i = limits.reserved_slots.size(); i > 0; --i) {
+    max_running_jobs_[i - 1] += spare;
+  }
+}
+
 }  // namespace net