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

net/base/host_resolver_impl.h

 // 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.
 
 #ifndef NET_BASE_HOST_RESOLVER_IMPL_H_
 #define NET_BASE_HOST_RESOLVER_IMPL_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 67 matching lines @@
   // If |cache| is NULL, then no caching is used. Otherwise we take
   // ownership of the |cache| pointer, and will free it during destructor.
   //
   // |resolver_proc| is used to perform the actual resolves; it must be
   // thread-safe since it is run from multiple worker threads. If
   // |resolver_proc| is NULL then the default host resolver procedure is
   // used (which is SystemHostResolverProc except if overridden).
   // |max_jobs| specifies the maximum number of threads that the host resolver
   // will use (not counting potential duplicate attempts). Use
   // SetPoolConstraints() to specify finer-grain settings.
+  // |max_retry_attempts| is the maximum number of times we will retry for host
+  // resolution. Pass HostResolver::kDefaultRetryAttempts to choose a default
+  // value.
   //
   // For each attempt, we could start another attempt if host is not resolved
   // within unresponsive_delay_ time. We keep attempting to resolve the host
   // until retry interval reaches maximum_unresponsive_delay_ time. For every
   // retry attempt, we grow the unresponsive_delay_ by the retry_factor_ amount
   // (that is retry interval is multiplied by the retry factor each time). Once
   // retry interval exceeds maximum_unresponsive_delay_ time, we give up on
   // additional attempts.
   //
   // |net_log| must remain valid for the life of the HostResolverImpl.
   HostResolverImpl(HostResolverProc* resolver_proc,
                    HostCache* cache,
                    size_t max_jobs,
+                   size_t max_retry_attempts,
                    NetLog* net_log);
 
   // If any completion callbacks are pending when the resolver is destroyed,
   // the host resolutions are cancelled, and the completion callbacks will not
   // be called.
   virtual ~HostResolverImpl();
 
   // Continuously observe whether IPv6 is supported, and set the allowable
   // address family to IPv4 iff IPv6 is not supported.
   void ProbeIPv6Support();
@@ skipping 132 matching lines @@
 
   // Cancels all jobs.
   void CancelAllJobs();
 
   // Aborts all in progress jobs (but might start new ones).
   void AbortAllInProgressJobs();
 
   // NetworkChangeNotifier::IPAddressObserver methods:
   virtual void OnIPAddressChanged();
 
+  // Helper methods to get and set max_retry_attempts_.
+  size_t max_retry_attempts() const {
+    return max_retry_attempts_;
+  }
+  void set_max_retry_attempts(const size_t max_retry_attempts) {
+    max_retry_attempts_ = max_retry_attempts;
+  }
+
   // Helper methods for unit tests to get and set unresponsive_delay_.
   base::TimeDelta unresponsive_delay() const { return unresponsive_delay_; }
   void set_unresponsive_delay(const base::TimeDelta& unresponsive_delay) {
     unresponsive_delay_ = unresponsive_delay;
   }
 
-  // Helper methods to get and set retry_factor.
+  // Helper methods to get and set retry_factor_.
   uint32 retry_factor() const {
     return retry_factor_;
   }
   void set_retry_factor(const uint32 retry_factor) {
     retry_factor_ = retry_factor;
   }
 
   // Helper methods for unit tests to get and set maximum_unresponsive_delay_.
   base::TimeDelta maximum_unresponsive_delay() const {
     return maximum_unresponsive_delay_;
   }
   void set_maximum_unresponsive_delay(
       const base::TimeDelta& maximum_unresponsive_delay) {
     maximum_unresponsive_delay_ = maximum_unresponsive_delay;
   }
 
   // Cache of host resolution results.
   scoped_ptr<HostCache> cache_;
 
   // Map from hostname to outstanding job.
   JobMap jobs_;
 
   // Maximum number of concurrent jobs allowed, across all pools. Each job may
   // create multiple concurrent resolve attempts for the hostname.
   size_t max_jobs_;
 
+  // Maximum number retry attempts to resolve the hostname.
+  size_t max_retry_attempts_;
+
   // This is the limit after which we make another attempt to resolve the host
   // if the worker thread has not responded yet. Allow unit tests to change the
   // value.
   base::TimeDelta unresponsive_delay_;
 
   // Factor to grow unresponsive_delay_ when we re-re-try. Allow unit tests to
   // change the value.
   uint32 retry_factor_;
 
   // This is the limit on how large we grow the retry interval. Once it exceeds
@@ skipping 42 matching lines @@
   HostResolverFlags additional_resolver_flags_;
 
   NetLog* net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(HostResolverImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_IMPL_H_