Add a command line flag to change the default number of parallel DNS requests issued by chrome.

  --host-resolver-parallelism=XXX

This is a useful debugging tool, since for some users too many parallel DNS requests results in spurious DNS failures from their resolver.

BUG=44489
Review URL: http://codereview.chromium.org/3019007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@52802 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 16 insertions, 4 deletions

diff --git a/net/base/host_resolver.h b/net/base/host_resolver.h
index 1e1fb0b..895ffc2 100644
--- a/net/base/host_resolver.h
+++ b/net/base/host_resolver.h
@@ -131,6 +131,11 @@ class HostResolver : public base::RefCounted<HostResolver> {
   // Opaque type used to cancel a request.
   typedef void* RequestHandle;
 
+  // This value can be passed into CreateSystemHostResolver as the
+  // |max_concurrent_resolves| parameter. It will select a default level of
+  // concurrency.
+  static const size_t kDefaultParallelism = 0;
+
   // Resolves the given hostname (or IP address literal), filling out the
   // |addresses| object upon success.  The |info.port| parameter will be set as
   // the sin(6)_port field of the sockaddr_in{6} struct.  Returns OK if
@@ -238,7 +243,10 @@ class SingleRequestHostResolver {
 // Creates a HostResolver implementation that queries the underlying system.
 // (Except if a unit-test has changed the global HostResolverProc using
 // ScopedHostResolverProc to intercept requests to the system).
-HostResolver* CreateSystemHostResolver();
+// |max_concurrent_resolves| is how many resolve requests will be allowed to
+// run in parallel. Pass HostResolver::kDefaultParallelism to choose a
+// default value.
+HostResolver* CreateSystemHostResolver(size_t max_concurrent_resolves);
 
 }  // namespace net
 
diff --git a/net/base/host_resolver_impl.cc b/net/base/host_resolver_impl.cc
index 9b19436..ffba57f 100644
--- a/net/base/host_resolver_impl.cc
+++ b/net/base/host_resolver_impl.cc
@@ -52,13 +52,17 @@ HostCache* CreateDefaultCache() {
 
 }  // anonymous namespace
 
-HostResolver* CreateSystemHostResolver() {
+HostResolver* CreateSystemHostResolver(size_t max_concurrent_resolves) {
   // Maximum of 50 concurrent threads.
   // TODO(eroman): Adjust this, do some A/B experiments.
-  static const size_t kMaxJobs = 50u;
+  static const size_t kDefaultMaxJobs = 50u;
+
+  if (max_concurrent_resolves == HostResolver::kDefaultParallelism)
+    max_concurrent_resolves = kDefaultMaxJobs;
 
   HostResolverImpl* resolver =
-      new HostResolverImpl(NULL, CreateDefaultCache(), kMaxJobs);
+      new HostResolverImpl(NULL, CreateDefaultCache(),
+                           max_concurrent_resolves);
 
   return resolver;
 }