Refactor DNS A/B experient, and add test of congestion time limits...

chrome/browser/net/dns_master.h

 // Copyright (c) 2006-2008 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.
 
 // A DnsMaster object is instantiated once in the browser
 // process, and manages asynchronous resolution of DNS hostnames.
 // Most hostname lists are sent out by renderer processes, and
 // involve lists of hostnames that *might* be used in the near
 // future by the browsing user.  The goal of this class is to
 // cause the underlying DNS structure to lookup a hostname before
 // it is really needed, and hence reduce latency in the standard
 // lookup paths.
 
 #ifndef CHROME_BROWSER_NET_DNS_MASTER_H_
 #define CHROME_BROWSER_NET_DNS_MASTER_H_
 
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 
 #include "base/lock.h"
 #include "base/ref_counted.h"
 #include "chrome/browser/net/dns_host_info.h"
 #include "chrome/browser/net/referrer.h"
 #include "chrome/common/net/dns.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
+using base::TimeDelta;
+
 namespace net {
 class HostResolver;
 }
 
 class MessageLoop;
 
 namespace chrome_browser_net {
 
 typedef chrome_common_net::NameList NameList;
 typedef std::map<std::string, DnsHostInfo> Results;
 
 class DnsMaster : public base::RefCountedThreadSafe<DnsMaster> {
  public:
   // |max_concurrent| specifies how many concurrent (paralell) prefetches will
   // be performed. Host lookups will be issued on the |host_resolver_loop|
   // thread, using the |host_resolver| instance.
-  DnsMaster(net::HostResolver* host_resolver,
-            MessageLoop* host_resolver_loop,
-            size_t max_concurrent);
+  DnsMaster(net::HostResolver* host_resolver, MessageLoop* host_resolver_loop,
+            TimeDelta max_queue_delay_ms, size_t max_concurrent);
   ~DnsMaster();
 
   // Cancel pending requests and prevent new ones from being made.
   void Shutdown();
 
   // In some circumstances, for privacy reasons, all results should be
   // discarded.  This method gracefully handles that activity.
   // Destroy all our internal state, which shows what names we've looked up, and
   // how long each has taken, etc. etc.  We also destroy records of suggesses
   // (cache hits etc.).
@@ skipping 162 matching lines @@
 
   // A list of successful events resulting from pre-fetching.
   DnsHostInfo::DnsInfoTable cache_hits_;
   // A map of hosts that were evicted from our cache (after we prefetched them)
   // and before the HTTP stack tried to look them up.
   Results cache_eviction_map_;
 
   // The number of concurrent lookups currently allowed.
   const size_t max_concurrent_lookups_;
 
+  // The maximum queueing delay that is acceptable before we enter congestion
+  // reduction mode, and discard all queued (but not yet assigned) resolutions.
+  const TimeDelta max_queue_delay_;
+
   // The host resovler we warm DNS entries for. The resolver (which is not
   // thread safe) should be accessed only on |host_resolver_loop_|.
   scoped_refptr<net::HostResolver> host_resolver_;
   MessageLoop* host_resolver_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsMaster);
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_DNS_MASTER_H_