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

[eroman, 2011/05/17 22:53:26]

Note that this does not work as described.

[ramant (doing other things), 2011/05/17 23:27:25]

Fixed.

Done.

+  // 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.
+  // for max_retry_attempts. 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 we have retried
+  // max_retry_attempts, 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
-  // this, we give up on additional attempts. Allow unit tests to change the
-  // value.
-  base::TimeDelta maximum_unresponsive_delay_;
-
   // The information to track pending requests for a JobPool, as well as
   // how many outstanding jobs the pool already has, and its constraints.
   JobPool* job_pools_[POOL_COUNT];
 
   // The job that OnJobComplete() is currently processing (needed in case
   // HostResolver gets deleted from within the callback).
   scoped_refptr<Job> cur_completing_job_;
 
   // The observers to notify when a request starts/ends.
   ObserversList observers_;
@@ skipping 28 matching lines @@
   HostResolverFlags additional_resolver_flags_;
 
   NetLog* net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(HostResolverImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_HOST_RESOLVER_IMPL_H_