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

chrome/browser/net/dns_global.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_global.h"
 
 #include <map>
 #include <string>
 
 #include "base/singleton.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/values.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/net/dns_host_info.h"
 #include "chrome/browser/net/referrer.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/session_startup_pref.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "net/base/host_resolver.h"
 
+using base::Time;
 using base::TimeDelta;
 
 namespace chrome_browser_net {
 
 static void DiscardAllPrefetchState();
 static void DnsMotivatedPrefetch(const std::string& hostname,
                                  DnsHostInfo::ResolutionMotivation motivation);
 static void DnsPrefetchMotivatedList(
     const NameList& hostnames,
     DnsHostInfo::ResolutionMotivation motivation);
 
 // static
 const size_t DnsPrefetcherInit::kMaxConcurrentLookups = 8;
 
+// static
+const int DnsPrefetcherInit::kMaxQueueingDelayMs = 1000;
+
 // Host resolver shared by DNS prefetcher, and the main URLRequestContext.
 static net::HostResolver* global_host_resolver = NULL;
 
 //------------------------------------------------------------------------------
 // This section contains all the globally accessable API entry points for the
 // DNS Prefetching feature.
 //------------------------------------------------------------------------------
 
 // Status of prefetch feature, controlling whether any prefetching is done.
 static bool dns_prefetch_enabled = true;
@@ skipping 223 matching lines @@
 
 // static
 void PrefetchObserver::SaveStartupListAsPref(PrefService* local_state) {
   ListValue* startup_list =
       local_state->GetMutableList(prefs::kDnsStartupPrefetchList);
 
   DCHECK(startup_list);
   if (!startup_list)
     return;
   startup_list->Clear();
-  DCHECK(startup_list->GetSize() == 0);
+  DCHECK_EQ(0u, startup_list->GetSize());
   AutoLock auto_lock(*lock);
   for (Results::iterator it = first_resolutions->begin();
        it != first_resolutions->end();
        it++) {
     const std::string hostname = it->first;
     startup_list->Append(Value::CreateStringValue(hostname));
   }
 }
 
 // static
@@ skipping 44 matching lines @@
           ++count_off_the_record_windows_;
         }
         OnTheRecord(false);
         break;
 
       case NotificationType::BROWSER_CLOSED:
         if (!Source<Browser>(source)->profile()->IsOffTheRecord())
           break;  // Ignore ordinary windows.
         {
           AutoLock lock(lock_);
-          DCHECK(0 < count_off_the_record_windows_);
+          DCHECK_LT(0, count_off_the_record_windows_);
           if (0 >= count_off_the_record_windows_)  // Defensive coding.
             break;
           if (--count_off_the_record_windows_)
             break;  // Still some windows are incognito.
         }  // Release lock.
         OnTheRecord(true);
         break;
 
       default:
         break;
@@ skipping 38 matching lines @@
 
 //------------------------------------------------------------------------------
 // This section intializes and tears down global DNS prefetch services.
 //------------------------------------------------------------------------------
 
 // Note: We have explicit permission to create the following global static
 // object (in opposition to Google style rules). By making it a static, we
 // can ensure its deletion.
 static PrefetchObserver dns_resolution_observer;
 
-void InitDnsPrefetch(size_t max_concurrent, PrefService* user_prefs) {
+void InitDnsPrefetch(TimeDelta max_queue_delay, size_t max_concurrent,
+                     PrefService* user_prefs) {
   // Use a large shutdown time so that UI tests (that instigate lookups, and
   // then try to shutdown the browser) don't instigate the CHECK about
   // "some slaves have not finished"
   const TimeDelta kAllowableShutdownTime(TimeDelta::FromSeconds(10));
   DCHECK(NULL == dns_master);
   if (!dns_master) {
     // Have the DnsMaster issue resolve requests through a global HostResolver
     // that is shared by the main URLRequestContext, and lives on the IO thread.
     dns_master = new DnsMaster(GetGlobalHostResolver(),
                                g_browser_process->io_thread()->message_loop(),
-                               max_concurrent);
+                               max_queue_delay, max_concurrent);
     dns_master->AddRef();
     // We did the initialization, so we should prime the pump, and set up
     // the DNS resolution system to run.
     Singleton<OffTheRecordObserver>::get()->Register();
 
     if (user_prefs) {
       bool enabled = user_prefs->GetBoolean(prefs::kDnsPrefetchingEnabled);
       EnableDnsPrefetch(enabled);
     }
 
@@ skipping 118 matching lines @@
       local_state->GetMutableList(prefs::kDnsHostReferralList);
   dns_master->DeserializeReferrers(*referral_list);
 }
 
 void TrimSubresourceReferrers() {
   if (NULL == dns_master)
     return;
   dns_master->TrimReferrers();
 }
 
+//------------------------------------------------------------------------------
+// Methods for the helper class that is used to startup and teardown the whole
+// DNS prefetch system.
+
+DnsPrefetcherInit::DnsPrefetcherInit(PrefService* user_prefs,
+                                     PrefService* local_state) {
+  // Set up a field trial to see what disabling DNS pre-resolution does to
+  // latency of page loads.
+  FieldTrial::Probability kDivisor = 100;
+  // For each option (i.e., non-default), we have a fixed probability.
+  FieldTrial::Probability kProbabilityPerGroup = 10;  // 10% probability.
+
+  trial_ = new FieldTrial("DnsImpact", kDivisor);
+
+  // First option is to disable prefetching completely.
+  int disabled_prefetch = trial_->AppendGroup("_disabled_prefetch",
+                                              kProbabilityPerGroup);
+  // Set parallel prefetch limit to 4 instead of default 8.
+  int parallel_4_prefetch = trial_->AppendGroup("_parallel_4_prefetch",
+                                                kProbabilityPerGroup);
+  // Set congestion detection at 500ms, rather than the 1 second default.
+  int max_500ms_prefetch = trial_->AppendGroup("_max_500ms_prefetch_queue",
+                                               kProbabilityPerGroup);
+  // Set congestion detection at 2 seconds instead of the 1 second default.
+  int max_2s_prefetch = trial_->AppendGroup("_max_2s_prefetch_queue",
+                                            kProbabilityPerGroup);
+
+  if (trial_->group() != disabled_prefetch) {
+    // Initialize the DNS prefetch system.
+
+    size_t max_concurrent = kMaxConcurrentLookups;
+
+    int max_queueing_delay_ms = kMaxQueueingDelayMs;
+
+    if (trial_->group() == parallel_4_prefetch)
+      max_concurrent = 4;
+    else if (trial_->group() == max_500ms_prefetch)
+      max_queueing_delay_ms = 500;
+    else if (trial_->group() == max_2s_prefetch)
+      max_queueing_delay_ms = 2000;
+
+    TimeDelta max_queueing_delay(
+        TimeDelta::FromMilliseconds(max_queueing_delay_ms));
+
+    DCHECK(!dns_master);
+    InitDnsPrefetch(max_queueing_delay, max_concurrent, user_prefs);
+    DCHECK(dns_master);  // Will be checked in destructor.
+    chrome_browser_net::DnsPrefetchHostNamesAtStartup(user_prefs, local_state);
+    chrome_browser_net::RestoreSubresourceReferrers(local_state);
+  }
+}
+
+DnsPrefetcherInit::~DnsPrefetcherInit() {
+    if (dns_master)
+      FreeDnsPrefetchResources();
+  }
+
 }  // namespace chrome_browser_net
+