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

chrome/browser/net/dns_master.cc

 // 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.
 
 #include "chrome/browser/net/dns_master.h"
 
 #include <algorithm>
 #include <set>
 #include <sstream>
 
 #include "base/compiler_specific.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/lock.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
 
+using base::TimeDelta;
+
 namespace chrome_browser_net {
 
 class DnsMaster::LookupRequest {
  public:
   LookupRequest(DnsMaster* master,
                 net::HostResolver* host_resolver,
                 const std::string& hostname)
       : ALLOW_THIS_IN_INITIALIZER_LIST(
           net_callback_(this, &LookupRequest::OnLookupFinished)),
         master_(master),
@@ skipping 28 matching lines @@
 
   const std::string hostname_;  // Hostname to resolve.
   net::SingleRequestHostResolver resolver_;
   net::AddressList addresses_;
 
   DISALLOW_COPY_AND_ASSIGN(LookupRequest);
 };
 
 DnsMaster::DnsMaster(net::HostResolver* host_resolver,
                      MessageLoop* host_resolver_loop,
+                     TimeDelta max_queue_delay,
                      size_t max_concurrent)
   : peak_pending_lookups_(0),
     shutdown_(false),
     max_concurrent_lookups_(max_concurrent),
+    max_queue_delay_(max_queue_delay),
     host_resolver_(host_resolver),
     host_resolver_loop_(host_resolver_loop) {
 }
 
 DnsMaster::~DnsMaster() {
   DCHECK(shutdown_);
 }
 
 void DnsMaster::Shutdown() {
   AutoLock auto_lock(lock_);
@@ skipping 258 matching lines @@
   }
 
   // Partition the DnsHostInfo's into categories.
   for (Snapshot::iterator it(snapshot.begin()); it != snapshot.end(); it++) {
     if (it->second.was_nonexistant()) {
       name_not_found.push_back(it->second);
       continue;
     }
     if (!it->second.was_found())
       continue;  // Still being processed.
-    if (base::TimeDelta() != it->second.benefits_remaining()) {
+    if (TimeDelta() != it->second.benefits_remaining()) {
       network_hits.push_back(it->second);  // With no benefit yet.
       continue;
     }
     if (DnsHostInfo::kMaxNonNetworkDnsLookupDuration >
       it->second.resolve_duration()) {
       already_cached.push_back(it->second);
       continue;
     }
     // Remaining case is where prefetch benefit was significant, and was used.
     // Since we shot those cases as historical hits, we won't bother here.
@@ skipping 14 matching lines @@
   DnsHostInfo::GetHtmlTable(already_cached,
       "Previously cached resolutions were found for ", brief, output);
   DnsHostInfo::GetHtmlTable(name_not_found,
       "Prefetching DNS records revealed non-existance for ", brief, output);
 }
 
 DnsHostInfo* DnsMaster::PreLockedResolve(
     const std::string& hostname,
     DnsHostInfo::ResolutionMotivation motivation) {
   // DCHECK(We have the lock);
-  DCHECK(0 != hostname.length());
+  DCHECK_NE(0u, hostname.length());
 
   if (shutdown_)
     return NULL;
 
   DnsHostInfo* info = &results_[hostname];
   info->SetHostname(hostname);  // Initialize or DCHECK.
   // TODO(jar):  I need to discard names that have long since expired.
   // Currently we only add to the domain map :-/
 
   DCHECK(info->HasHostname(hostname));
@@ skipping 38 matching lines @@
       // there was (equivalently) some network error that prevents us from
       // finding the name.  Status net::OK means it was "found."
       PrelockedLookupFinished(request, hostname, status == net::OK);
       delete request;
     }
   }
 }
 
 bool DnsMaster::PreLockedCongestionControlPerformed(DnsHostInfo* info) {
   // Note: queue_duration is ONLY valid after we go to assigned state.
-  // TODO(jar): Tune selection of arbitrary 1 second constant.  Add plumbing so
-  // that this can be set as part of an A/B experiment.
-  if (info->queue_duration() < base::TimeDelta::FromSeconds(1))
+  if (info->queue_duration() < max_queue_delay_)
     return false;
   // We need to discard all entries in our queue, as we're keeping them waiting
   // too long.  By doing this, we'll have a chance to quickly service urgent
   // resolutions, and not have a bogged down system.
   while (true) {
     info->RemoveFromQueue();
     if (work_queue_.IsEmpty())
       break;
     info = &results_[work_queue_.Pop()];
     info->SetAssignedState();
@@ skipping 149 matching lines @@
     std::string hostname(rush_queue_.front());
     rush_queue_.pop();
     return hostname;
   }
   std::string hostname(background_queue_.front());
   background_queue_.pop();
   return hostname;
 }
 
 }  // namespace chrome_browser_net