Add a command line option to turn off retry attempts to resolve host

net/base/host_resolver_impl.cc

 // Copyright (c) 2011 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/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
@@ skipping 79 matching lines @@
       base::TimeDelta::FromMinutes(1),
       base::TimeDelta::FromSeconds(0));  // Disable caching of failed DNS.
 
   return cache;
 }
 
 }  // anonymous namespace
 
 // static
 HostResolver* CreateSystemHostResolver(size_t max_concurrent_resolves,
+                                       size_t max_retry_attempts,
                                        NetLog* net_log) {
   // Maximum of 8 concurrent resolver threads.
   // Some routers (or resolvers) appear to start to provide host-not-found if
   // too many simultaneous resolutions are pending.  This number needs to be
   // further optimized, but 8 is what FF currently does.
   static const size_t kDefaultMaxJobs = 8u;
 
   if (max_concurrent_resolves == HostResolver::kDefaultParallelism)
     max_concurrent_resolves = kDefaultMaxJobs;
 
+  // Maximum of 4 retry attempts for host resolution.
+  static const size_t kDefaultMaxRetryAttempts = 4u;
+
+  if (max_retry_attempts == HostResolver::kDefaultRetryAttempts)
+    max_retry_attempts = kDefaultMaxRetryAttempts;
+
   HostResolverImpl* resolver =
-      new HostResolverImpl(NULL, CreateDefaultCache(),
-                           max_concurrent_resolves, net_log);
+      new HostResolverImpl(NULL, CreateDefaultCache(), max_concurrent_resolves,
+                           max_retry_attempts, net_log);
 
   return resolver;
 }
 
 static int ResolveAddrInfo(HostResolverProc* resolver_proc,
                            const std::string& host,
                            AddressFamily address_family,
                            HostResolverFlags host_resolver_flags,
                            AddressList* out,
                            int* os_error) {
@@ skipping 307 matching lines @@
       origin_loop_->PostTask(
           FROM_HERE,
           NewRunnableMethod(this, &Job::OnLookupComplete, AddressList(),
                             start_time, attempt_number_, ERR_UNEXPECTED, 0));
       return;
     }
     // Post a task to check if we get the results within a given time.
     // OnCheckForComplete has the potential for starting a new attempt on a
     // different worker thread if none of our outstanding attempts have
     // completed yet.
-    origin_loop_->PostDelayedTask(
-        FROM_HERE,
-        NewRunnableMethod(this, &Job::OnCheckForComplete),
-        unresponsive_delay_.InMilliseconds());
+    if (attempt_number_ <= resolver_->max_retry_attempts()) {
+      origin_loop_->PostDelayedTask(
+          FROM_HERE,
+          NewRunnableMethod(this, &Job::OnCheckForComplete),
+          unresponsive_delay_.InMilliseconds());
+    }
   }
 
   // Cancels the current job. The Job will be orphaned. Any outstanding resolve
   // attempts running on worker threads will continue running. Only once all the
   // attempts complete will the final reference to this Job be released.
   void Cancel() {
     DCHECK(origin_loop_->BelongsToCurrentThread());
     net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
 
     HostResolver* resolver = resolver_;
@@ skipping 79 matching lines @@
     origin_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &Job::OnLookupComplete, results, start_time,
                           attempt_number, error, os_error));
   }
 
   // Callback to see if DoLookup() has finished or not (runs on origin thread).
   void OnCheckForComplete() {
     DCHECK(origin_loop_->BelongsToCurrentThread());
 
-    if (was_cancelled() || was_completed())
+    if (was_completed() || was_cancelled())
       return;
 
     DCHECK(resolver_);
-    base::TimeDelta unresponsive_delay =
-        unresponsive_delay_ * resolver_->retry_factor();
-    if (unresponsive_delay >= resolver_->maximum_unresponsive_delay())
-      return;
-
-    unresponsive_delay_ = unresponsive_delay;
+    unresponsive_delay_ *= resolver_->retry_factor();
     StartLookupAttempt();
   }
 
   // Callback for when DoLookup() completes (runs on origin thread).
   void OnLookupComplete(const AddressList& results,
                         const base::TimeTicks& start_time,
                         const uint32 attempt_number,
                         int error,
                         const int os_error) {
     DCHECK(origin_loop_->BelongsToCurrentThread());
@@ skipping 441 matching lines @@
   // The requests which are waiting to be started for this pool.
   PendingRequestsQueue pending_requests_[NUM_PRIORITIES];
 };
 
 //-----------------------------------------------------------------------------
 
 HostResolverImpl::HostResolverImpl(
     HostResolverProc* resolver_proc,
     HostCache* cache,
     size_t max_jobs,
+    size_t max_retry_attempts,
     NetLog* net_log)
     : cache_(cache),
       max_jobs_(max_jobs),
+      max_retry_attempts_(max_retry_attempts),
       unresponsive_delay_(base::TimeDelta::FromMilliseconds(6000)),
       retry_factor_(2),
-      maximum_unresponsive_delay_(base::TimeDelta::FromMilliseconds(60000)),
       next_request_id_(0),
       next_job_id_(0),
       resolver_proc_(resolver_proc),
       default_address_family_(ADDRESS_FAMILY_UNSPECIFIED),
       shutdown_(false),
       ipv6_probe_monitoring_(false),
       additional_resolver_flags_(0),
       net_log_(net_log) {
   DCHECK_GT(max_jobs, 0u);
 
@@ skipping 478 matching lines @@
 }
 
 HostResolverImpl::Job* HostResolverImpl::CreateAndStartJob(Request* req) {
   DCHECK(CanCreateJobForPool(*GetPoolForRequest(req)));
   Key key = GetEffectiveKeyForRequest(req->info());
 
   req->request_net_log().AddEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_CREATE_JOB,
                                   NULL);
 
   scoped_refptr<Job> job(new Job(next_job_id_++, this, key,
-                                   req->request_net_log(), net_log_));
+                                 req->request_net_log(), net_log_));
   job->AddRequest(req);
   AddOutstandingJob(job);
   job->Start();
 
   return job.get();
 }
 
 int HostResolverImpl::EnqueueRequest(JobPool* pool, Request* req) {
   scoped_ptr<Request> req_evicted_from_queue(
       pool->InsertPendingRequest(req));
@@ skipping 50 matching lines @@
     additional_resolver_flags_ |= HOST_RESOLVER_LOOPBACK_ONLY;
   } else {
     additional_resolver_flags_ &= ~HOST_RESOLVER_LOOPBACK_ONLY;
   }
 #endif
   AbortAllInProgressJobs();
   // |this| may be deleted inside AbortAllInProgressJobs().
 }
 
 }  // namespace net