Modifying prefetch to account for multi-profile.

chrome/browser/chrome_browser_main.cc

 // 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.
 
 #include "chrome/browser/chrome_browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 33 matching lines @@
 #include "chrome/browser/jankometer.h"
 #include "chrome/browser/language_usage_metrics.h"
 #include "chrome/browser/metrics/field_trial_synchronizer.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker.h"
 #include "chrome/browser/net/chrome_dns_cert_provenance_checker_factory.h"
 #include "chrome/browser/net/chrome_net_log.h"
-#include "chrome/browser/net/predictor_api.h"
+#include "chrome/browser/net/predictor.h"
 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
 #include "chrome/browser/plugin_prefs.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_value_store.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/process_singleton.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 902 matching lines @@
                 30));
     const int connect_backup_jobs_enabled = trial->kDefaultGroupNumber;
     trial->AppendGroup("ConnectBackupJobsDisabled",
                        kConnectBackupJobsProbability);
     const int trial_group = trial->group();
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         trial_group == connect_backup_jobs_enabled);
   }
 }
 
+void ChromeBrowserMainParts::PredictorFieldTrial() {
+  const base::FieldTrial::Probability kDivisor = 1000;
+  // For each option (i.e., non-default), we have a fixed probability.
+  // 0.1% probability.
+  const base::FieldTrial::Probability kProbabilityPerGroup = 1;
+
+  // After June 30, 2011 builds, it will always be in default group
+  // (default_enabled_prefetch).
+  scoped_refptr<base::FieldTrial> trial(
+      new base::FieldTrial("DnsImpact", kDivisor,
+                           "default_enabled_prefetch", 2011, 10, 30));
+
+  // First option is to disable prefetching completely.
+  int disabled_prefetch = trial->AppendGroup("disabled_prefetch",
+                                              kProbabilityPerGroup);
+
+  // We're running two experiments at the same time.  The first set of trials
+  // modulates the delay-time until we declare a congestion event (and purge
+  // our queue).  The second modulates the number of concurrent resolutions
+  // we do at any time.  Users are in exactly one trial (or the default) during
+  // any one run, and hence only one experiment at a time.
+  // Experiment 1:
+  // Set congestion detection at 250, 500, or 750ms, rather than the 1 second
+  // default.
+  int max_250ms_prefetch = trial->AppendGroup("max_250ms_queue_prefetch",
+                                              kProbabilityPerGroup);
+  int max_500ms_prefetch = trial->AppendGroup("max_500ms_queue_prefetch",
+                                              kProbabilityPerGroup);
+  int max_750ms_prefetch = trial->AppendGroup("max_750ms_queue_prefetch",
+                                              kProbabilityPerGroup);
+  // Set congestion detection at 2 seconds instead of the 1 second default.
+  int max_2s_prefetch = trial->AppendGroup("max_2s_queue_prefetch",
+                                           kProbabilityPerGroup);
+  // Experiment 2:
+  // Set max simultaneous resoultions to 2, 4, or 6, and scale the congestion
+  // limit proportionally (so we don't impact average probability of asserting
+  // congesion very much).
+  int max_2_concurrent_prefetch = trial->AppendGroup(
+      "max_2 concurrent_prefetch", kProbabilityPerGroup);
+  int max_4_concurrent_prefetch = trial->AppendGroup(
+      "max_4 concurrent_prefetch", kProbabilityPerGroup);
+  int max_6_concurrent_prefetch = trial->AppendGroup(
+      "max_6 concurrent_prefetch", kProbabilityPerGroup);
+
+  if (trial->group() != disabled_prefetch) {
+    // Initialize the DNS prefetch system.
+    size_t max_parallel_resolves =
+        chrome_browser_net::Predictor::kMaxSpeculativeParallelResolves;
+    int max_queueing_delay_ms =
+        chrome_browser_net::Predictor::kMaxSpeculativeResolveQueueDelayMs;
+
+    if (trial->group() == max_2_concurrent_prefetch)
+      max_parallel_resolves = 2;
+    else if (trial->group() == max_4_concurrent_prefetch)
+      max_parallel_resolves = 4;
+    else if (trial->group() == max_6_concurrent_prefetch)
+      max_parallel_resolves = 6;
+    chrome_browser_net::Predictor::set_max_parallel_resolves(
+        max_parallel_resolves);
+
+    if (trial->group() == max_250ms_prefetch) {
+      max_queueing_delay_ms =
+         (250 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+         max_parallel_resolves;
+    } else if (trial->group() == max_500ms_prefetch) {
+      max_queueing_delay_ms =
+          (500 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+          max_parallel_resolves;
+    } else if (trial->group() == max_750ms_prefetch) {
+      max_queueing_delay_ms =
+          (750 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+          max_parallel_resolves;
+    } else if (trial->group() == max_2s_prefetch) {
+      max_queueing_delay_ms =
+          (2000 * chrome_browser_net::Predictor::kTypicalSpeculativeGroupSize) /
+          max_parallel_resolves;
+    }
+    chrome_browser_net::Predictor::set_max_queueing_delay(
+        max_queueing_delay_ms);
+  }
+}
+
 // Test the impact on subsequent Google searches of getting suggestions from
 // www.google.TLD instead of clients1.google.TLD.
 void ChromeBrowserMainParts::SuggestPrefixFieldTrial() {
   const base::FieldTrial::Probability kSuggestPrefixDivisor = 100;
   // 50% probability.
   const base::FieldTrial::Probability kSuggestPrefixProbability = 50;
   // After Jan 1, 2012, it will always be in default group.
   scoped_refptr<base::FieldTrial> trial(
       new base::FieldTrial("SuggestHostPrefix",
           kSuggestPrefixDivisor, "Default_Prefix", 2012, 1, 1));
@@ skipping 51 matching lines @@
   // If a policy is defining the number of active connections this field test
   // shoud not be performed.
   if (!proxy_policy_is_set)
     ProxyConnectionsFieldTrial();
   prerender::ConfigurePrefetchAndPrerender(parsed_command_line());
   InstantFieldTrial::Activate();
   SpdyFieldTrial();
   ConnectBackupJobsFieldTrial();
   SuggestPrefixFieldTrial();
   WarmConnectionFieldTrial();
+  PredictorFieldTrial();
 }
 
 // -----------------------------------------------------------------------------
 // TODO(viettrungluu): move more/rest of BrowserMain() into BrowserMainParts.
 
 #if defined(OS_CHROMEOS)
 // Allows authenticator to be invoked without adding refcounting. The instances
 // will delete themselves upon completion.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(StubLogin);
 #endif
@@ skipping 484 matching lines @@
 #if defined(OS_WIN)
   // Registers Chrome with the Windows Restart Manager, which will restore the
   // Chrome session when the computer is restarted after a system update.
   // This could be run as late as WM_QUERYENDSESSION for system update reboots,
   // but should run on startup if extended to handle crashes/hangs/patches.
   // Also, better to run once here than once for each HWND's WM_QUERYENDSESSION.
   if (base::win::GetVersion() >= base::win::VERSION_VISTA)
     RegisterApplicationRestart(parsed_command_line());
 #endif  // OS_WIN
 
-  // Initialize and maintain network predictor module, which handles DNS
-  // pre-resolution, as well as TCP/IP connection pre-warming.
-  // This also registers an observer to discard data when closing incognito
-  // mode.
-  bool preconnect_enabled = true;  // Default status (easy to change!).
-  if (parsed_command_line().HasSwitch(switches::kDisablePreconnect))
-    preconnect_enabled = false;
-  else if (parsed_command_line().HasSwitch(switches::kEnablePreconnect))
-    preconnect_enabled = true;
-  chrome_browser_net::PredictorInit dns_prefetch(
-      user_prefs,
-      local_state,
-      preconnect_enabled);
-
 #if defined(OS_WIN) && defined(GOOGLE_CHROME_BUILD)
   // Init the RLZ library. This just binds the dll and schedules a task on the
   // file thread to be run sometime later. If this is the first run we record
   // the installation event.
   bool google_search_default = false;
   TemplateURLService* template_url_service =
       TemplateURLServiceFactory::GetForProfile(profile_);
   if (template_url_service) {
     const TemplateURL* url_template =
         template_url_service->GetDefaultSearchProvider();
@@ skipping 357 matching lines @@
   if (env->GetVar(chrome::kPreReadEnvironmentVariable, &pre_read) &&
       (pre_read == "0" || pre_read == "1")) {
     std::string uma_name(name);
     uma_name += "_PreRead";
     uma_name += pre_read == "1" ? "Enabled" : "Disabled";
     AddPreReadHistogramTime(uma_name.c_str(), time);
   }
 #endif
 #endif
 }