[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) {
+      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];
     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;
   }
 }
 
 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]) {
+  if (!disabled_ && 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 (!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);
 }
 
 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() {
+  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);
   ++num_running_jobs_;
   job->Start();
   return true;
 }
 
 }  // namespace net