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

net/base/prioritized_dispatcher.cc

Index: net/base/prioritized_dispatcher.cc
===================================================================
--- net/base/prioritized_dispatcher.cc	(revision 218288)
+++ net/base/prioritized_dispatcher.cc	(working copy)
@@ -17,7 +17,8 @@
 PrioritizedDispatcher::PrioritizedDispatcher(const Limits& limits)
     : queue_(limits.reserved_slots.size()),
       max_running_jobs_(limits.reserved_slots.size()),
-      num_running_jobs_(0) {
+      num_running_jobs_(0),
+      disabled_(false) {
   size_t total = 0;
   for (size_t i = 0; i < limits.reserved_slots.size(); ++i) {
     total += limits.reserved_slots[i];
@@ -37,7 +38,7 @@
     Job* job, Priority priority) {
   DCHECK(job);
   DCHECK_LT(priority, num_priorities());
-  if (num_running_jobs_ < max_running_jobs_[priority]) {
+  if (!disabled_ && num_running_jobs_ < max_running_jobs_[priority]) {
     ++num_running_jobs_;
     job->Start();
     return Handle();
@@ -45,6 +46,18 @@
   return queue_.Insert(job, priority);
 }
 
+PrioritizedDispatcher::Handle PrioritizedDispatcher::AddAtHead(
+    Job* job, Priority priority) {
+  DCHECK(job);
+  DCHECK_LT(priority, num_priorities());
+  if (!disabled_ && 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);
 }
@@ -86,10 +99,14 @@
   MaybeDispatchJob(handle, handle.priority());
 }
 
+void PrioritizedDispatcher::Disable() {
+  disabled_ = true;
+}
+
 bool PrioritizedDispatcher::MaybeDispatchJob(const Handle& handle,
                                              Priority job_priority) {
   DCHECK_LT(job_priority, num_priorities());
-  if (num_running_jobs_ >= max_running_jobs_[job_priority])
+  if (disabled_ || num_running_jobs_ >= max_running_jobs_[job_priority])

[szym, 2013/08/19 20:49:34]

If instead of |disabled_|, you set max_running_jobs_ to 0, you wouldn't need an
extra condition in all these codepaths.

While it does make it possible for there to be more outstanding jobs than the
max_running_jobs_, I don't think should stop us (and in the future we might
bechanging the limit dynamically).

[mmenke, 2013/08/19 21:09:59]

Not sure why this didn't occur to me.  It's pretty easy to make SetLimits start
new jobs if needed, but I've chosen not to do so, simply because it seems beyond
the scope of this CL and we currently don't need it.  If you prefer that I add
support for that, however, happy to do so.

     return false;
   Job* job = handle.value();
   queue_.Erase(handle);