Feature to disable field trials in old versions of Chromium. Field trials...

chrome/browser/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/browser_main.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 213 matching lines @@
 // This is an A/B test for the maximum number of persistent connections per
 // host. Currently Chrome, Firefox, and IE8 have this value set at 6. Safari
 // uses 4, and Fasterfox (a plugin for Firefox that supposedly configures it to
 // run faster) uses 8. We would like to see how much of an effect this value has
 // on browsing. Too large a value might cause us to run into SYN flood detection
 // mechanisms.
 void BrowserMainParts::ConnectionFieldTrial() {
   const base::FieldTrial::Probability kConnectDivisor = 100;
   const base::FieldTrial::Probability kConnectProbability = 1;  // 1% prob.
 
+  // After June 30, 2011 builds, it will always be in defaut group.
   scoped_refptr<base::FieldTrial> connect_trial(
-      new base::FieldTrial("ConnCountImpact", kConnectDivisor));
+      new base::FieldTrial("ConnCountImpact", kConnectDivisor,
+          "conn_count_6", 2011, 6, 30));
+
+  // This (6) is the current default value. Having this group declared here
+  // makes it straightforward to modify |kConnectProbability| such that the same
+  // probability value will be assigned to all the other groups, while
+  // preserving the remainder of the of probability space to the default value.
+  const int connect_6 = connect_trial->kDefaultGroupNumber;
 
   const int connect_5 = connect_trial->AppendGroup("conn_count_5",
                                                    kConnectProbability);
   const int connect_7 = connect_trial->AppendGroup("conn_count_7",
                                                    kConnectProbability);
   const int connect_8 = connect_trial->AppendGroup("conn_count_8",
                                                    kConnectProbability);
   const int connect_9 = connect_trial->AppendGroup("conn_count_9",
                                                    kConnectProbability);
-  // This (6) is the current default value. Having this group declared here
-  // makes it straightforward to modify |kConnectProbability| such that the same
-  // probability value will be assigned to all the other groups, while
-  // preserving the remainder of the of probability space to the default value.
-  const int connect_6 = connect_trial->AppendGroup("conn_count_6",
-      base::FieldTrial::kAllRemainingProbability);
 
   const int connect_trial_group = connect_trial->group();
 
   if (connect_trial_group == connect_5) {
     net::ClientSocketPoolManager::set_max_sockets_per_group(5);
   } else if (connect_trial_group == connect_6) {
     net::ClientSocketPoolManager::set_max_sockets_per_group(6);
   } else if (connect_trial_group == connect_7) {
     net::ClientSocketPoolManager::set_max_sockets_per_group(7);
   } else if (connect_trial_group == connect_8) {
     net::ClientSocketPoolManager::set_max_sockets_per_group(8);
   } else if (connect_trial_group == connect_9) {
     net::ClientSocketPoolManager::set_max_sockets_per_group(9);
   } else {
     NOTREACHED();
   }
 }
 
 // A/B test for determining a value for unused socket timeout. Currently the
 // timeout defaults to 10 seconds. Having this value set too low won't allow us
 // to take advantage of idle sockets. Setting it to too high could possibly
 // result in more ERR_CONNECT_RESETs, requiring one RTT to receive the RST
 // packet and possibly another RTT to re-establish the connection.
 void BrowserMainParts::SocketTimeoutFieldTrial() {
   const base::FieldTrial::Probability kIdleSocketTimeoutDivisor = 100;
   // 1% probability for all experimental settings.
   const base::FieldTrial::Probability kSocketTimeoutProbability = 1;
 
+  // After June 30, 2011 builds, it will always be in defaut group.
   scoped_refptr<base::FieldTrial> socket_timeout_trial(
-      new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor));
+      new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor,
+          "idle_timeout_60", 2011, 6, 30));
+  const int socket_timeout_60 = socket_timeout_trial->kDefaultGroupNumber;
 
   const int socket_timeout_5 =
       socket_timeout_trial->AppendGroup("idle_timeout_5",
                                         kSocketTimeoutProbability);
   const int socket_timeout_10 =
       socket_timeout_trial->AppendGroup("idle_timeout_10",
                                         kSocketTimeoutProbability);
   const int socket_timeout_20 =
       socket_timeout_trial->AppendGroup("idle_timeout_20",
                                         kSocketTimeoutProbability);
-  const int socket_timeout_60 =
-      socket_timeout_trial->AppendGroup("idle_timeout_60",
-          base::FieldTrial::kAllRemainingProbability);
 
   const int idle_to_trial_group = socket_timeout_trial->group();
 
   if (idle_to_trial_group == socket_timeout_5) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(5);
   } else if (idle_to_trial_group == socket_timeout_10) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(10);
   } else if (idle_to_trial_group == socket_timeout_20) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(20);
   } else if (idle_to_trial_group == socket_timeout_60) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(60);
   } else {
     NOTREACHED();
   }
 }
 
 void BrowserMainParts::ProxyConnectionsFieldTrial() {
   const base::FieldTrial::Probability kProxyConnectionsDivisor = 100;
   // 25% probability
   const base::FieldTrial::Probability kProxyConnectionProbability = 1;
 
+  // After June 30, 2011 builds, it will always be in defaut group.
   scoped_refptr<base::FieldTrial> proxy_connection_trial(
-      new base::FieldTrial("ProxyConnectionImpact", kProxyConnectionsDivisor));
+      new base::FieldTrial("ProxyConnectionImpact", kProxyConnectionsDivisor,
+          "proxy_connections_32", 2011, 6, 30));
+
+  // This (32 connections per proxy server) is the current default value.
+  // Declaring it here allows us to easily re-assign the probability space while
+  // maintaining that the default group always has the remainder of the "share",
+  // which allows for cleaner and quicker changes down the line if needed.
+  const int proxy_connections_32 = proxy_connection_trial->kDefaultGroupNumber;
 
   // The number of max sockets per group cannot be greater than the max number
   // of sockets per proxy server.  We tried using 8, and it can easily
   // lead to total browser stalls.
   const int proxy_connections_16 =
       proxy_connection_trial->AppendGroup("proxy_connections_16",
                                           kProxyConnectionProbability);
   const int proxy_connections_64 =
       proxy_connection_trial->AppendGroup("proxy_connections_64",
                                           kProxyConnectionProbability);
 
-  // This (32 connections per proxy server) is the current default value.
-  // Declaring it here allows us to easily re-assign the probability space while
-  // maintaining that the default group always has the remainder of the "share",
-  // which allows for cleaner and quicker changes down the line if needed.
-  const int proxy_connections_32 =
-      proxy_connection_trial->AppendGroup("proxy_connections_32",
-          base::FieldTrial::kAllRemainingProbability);
-
   const int proxy_connections_trial_group = proxy_connection_trial->group();
 
   if (proxy_connections_trial_group == proxy_connections_16) {
     net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(16);
   } else if (proxy_connections_trial_group == proxy_connections_32) {
     net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(32);
   } else if (proxy_connections_trial_group == proxy_connections_64) {
     net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(64);
   } else {
     NOTREACHED();
@@ skipping 10 matching lines @@
 void BrowserMainParts::SpdyFieldTrial() {
   bool is_spdy_trial = false;
   if (parsed_command_line().HasSwitch(switches::kUseSpdy)) {
     std::string spdy_mode =
         parsed_command_line().GetSwitchValueASCII(switches::kUseSpdy);
     net::HttpNetworkLayer::EnableSpdy(spdy_mode);
   } else {
     const base::FieldTrial::Probability kSpdyDivisor = 100;
     // 10% to preclude SPDY.
     base::FieldTrial::Probability npnhttp_probability = 10;
+
+    // After June 30, 2011 builds, it will always be in defaut group.
     scoped_refptr<base::FieldTrial> trial(
-        new base::FieldTrial("SpdyImpact", kSpdyDivisor));
+        new base::FieldTrial("SpdyImpact", kSpdyDivisor, "npn_with_spdy", 2011,
+            6, 30));
+
+    // npn with spdy support is the default.
+    int npn_spdy_grp = trial->kDefaultGroupNumber;
+
     // npn with only http support, no spdy.
     int npn_http_grp = trial->AppendGroup("npn_with_http", npnhttp_probability);
-    // npn with spdy support.
-    int npn_spdy_grp = trial->AppendGroup("npn_with_spdy",
-        base::FieldTrial::kAllRemainingProbability);
+
     int trial_grp = trial->group();
     if (trial_grp == npn_http_grp) {
       is_spdy_trial = true;
       net::HttpNetworkLayer::EnableSpdy("npn-http");
     } else if (trial_grp == npn_spdy_grp) {
       is_spdy_trial = true;
       net::HttpNetworkLayer::EnableSpdy("npn");
     } else {
       CHECK(!is_spdy_trial);
     }
   }
 
   // Setup SPDY CWND Field trial.
   const base::FieldTrial::Probability kSpdyCwndDivisor = 100;
   const base::FieldTrial::Probability kSpdyCwnd32 = 20;     // fixed at 32
   const base::FieldTrial::Probability kSpdyCwnd16 = 20;     // fixed at 16
   const base::FieldTrial::Probability kSpdyCwndMin16 = 20;  // no less than 16
   const base::FieldTrial::Probability kSpdyCwndMin10 = 20;  // no less than 10
+  const base::FieldTrial::Probability kSpdyCwndSynamic = 20;
+
+  // After June 30, 2011 builds, it will always be in defaut group
+  // (cwndDynamic).
   scoped_refptr<base::FieldTrial> trial(
-      new base::FieldTrial("SpdyCwnd", kSpdyCwndDivisor));
+      new base::FieldTrial("SpdyCwnd", kSpdyCwndDivisor, "cwndDynamic", 2011,
+          6, 30));
+
   trial->AppendGroup("cwnd32", kSpdyCwnd32);
   trial->AppendGroup("cwnd16", kSpdyCwnd16);
   trial->AppendGroup("cwndMin16", kSpdyCwndMin16);
   trial->AppendGroup("cwndMin10", kSpdyCwndMin10);
-  trial->AppendGroup("cwndDynamic",
-                     base::FieldTrial::kAllRemainingProbability);
+  trial->AppendGroup("cwndDynamic", kSpdyCwndSynamic);
+
+  // Finalize the group assignment.
+  trial->group();
 
   if (parsed_command_line().HasSwitch(switches::kMaxSpdyConcurrentStreams)) {
     int value = 0;
     base::StringToInt(parsed_command_line().GetSwitchValueASCII(
             switches::kMaxSpdyConcurrentStreams),
         &value);
     if (value > 0)
       net::SpdySession::set_max_concurrent_streams(value);
   }
 }
 
 // If any of --enable-prerender, --enable-content-prefetch or
 // --disable-content-prefetch are set, use those to determine if
 // prefetch is enabled. Otherwise, randomly assign users to an A/B test for
 // prefetching.
 void BrowserMainParts::PrefetchFieldTrial() {
   if (parsed_command_line().HasSwitch(switches::kEnableContentPrefetch) ||
       parsed_command_line().HasSwitch(switches::kEnablePagePrerender))
     ResourceDispatcherHost::set_is_prefetch_enabled(true);
   else if (parsed_command_line().HasSwitch(switches::kDisableContentPrefetch)) {
     ResourceDispatcherHost::set_is_prefetch_enabled(false);
   } else {
     const base::FieldTrial::Probability kPrefetchDivisor = 1000;
     const base::FieldTrial::Probability no_prefetch_probability = 500;
+    // After June 30, 2011 builds, it will always be in defaut group.
     scoped_refptr<base::FieldTrial> trial(
-        new base::FieldTrial("Prefetch", kPrefetchDivisor));
+        new base::FieldTrial("Prefetch", kPrefetchDivisor,
+            "ContentPrefetchEnabled", 2011, 6, 30));
+    const int yes_prefetch_grp = trial->kDefaultGroupNumber;
     trial->AppendGroup("ContentPrefetchDisabled", no_prefetch_probability);
-    const int yes_prefetch_grp =
-        trial->AppendGroup("ContentPrefetchEnabled",
-                           base::FieldTrial::kAllRemainingProbability);
     const int trial_grp = trial->group();
     ResourceDispatcherHost::set_is_prefetch_enabled(
         trial_grp == yes_prefetch_grp);
   }
 }
 
 // If neither --enable-connect-backup-jobs or --disable-connect-backup-jobs is
 // specified, run an A/B test for automatically establishing backup TCP
 // connections when a certain timeout value is exceeded.
 void BrowserMainParts::ConnectBackupJobsFieldTrial() {
   if (parsed_command_line().HasSwitch(switches::kEnableConnectBackupJobs)) {
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         true);
   } else if (parsed_command_line().HasSwitch(
         switches::kDisableConnectBackupJobs)) {
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         false);
   } else {
     const base::FieldTrial::Probability kConnectBackupJobsDivisor = 100;
     // 1% probability.
     const base::FieldTrial::Probability kConnectBackupJobsProbability = 1;
+    // After June 30, 2011 builds, it will always be in defaut group.
     scoped_refptr<base::FieldTrial> trial(
         new base::FieldTrial("ConnnectBackupJobs",
-                             kConnectBackupJobsDivisor));
+            kConnectBackupJobsDivisor, "ConnectBackupJobsEnabled", 2011, 6,
+                30));
+    const int connect_backup_jobs_enabled = trial->kDefaultGroupNumber;
     trial->AppendGroup("ConnectBackupJobsDisabled",
                        kConnectBackupJobsProbability);
-    const int connect_backup_jobs_enabled =
-        trial->AppendGroup("ConnectBackupJobsEnabled",
-                           base::FieldTrial::kAllRemainingProbability);
     const int trial_group = trial->group();
     net::internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
         trial_group == connect_backup_jobs_enabled);
   }
 }
 
 // BrowserMainParts: |MainMessageLoopStart()| and related ----------------------
 
 void BrowserMainParts::MainMessageLoopStart() {
   PreMainMessageLoopStart();
@@ skipping 1056 matching lines @@
 
   // Do initialize the plug-in service (and related preferences).
   PluginService::InitGlobalInstance(profile);
 
   // Prepare for memory caching of SDCH dictionaries.
   // Perform A/B test to measure global impact of SDCH support.
   // Set up a field trial to see what disabling SDCH does to latency of page
   // layout globally.
   base::FieldTrial::Probability kSDCH_DIVISOR = 1000;
   base::FieldTrial::Probability kSDCH_DISABLE_PROBABILITY = 1;  // 0.1% prob.
+  // After June 30, 2011 builds, it will always be in defaut group.
   scoped_refptr<base::FieldTrial> sdch_trial(
-      new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR));
+      new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR, "global_enable_sdch",
+          2011, 6, 30));
+  int sdch_enabled = sdch_trial->kDefaultGroupNumber;
 
   // Use default of "" so that all domains are supported.
   std::string sdch_supported_domain("");
   if (parsed_command_line.HasSwitch(switches::kSdchFilter)) {
     sdch_supported_domain =
         parsed_command_line.GetSwitchValueASCII(switches::kSdchFilter);
   } else {
     sdch_trial->AppendGroup("global_disable_sdch",
                             kSDCH_DISABLE_PROBABILITY);
-    int sdch_enabled = sdch_trial->AppendGroup("global_enable_sdch",
-        base::FieldTrial::kAllRemainingProbability);
     if (sdch_enabled != sdch_trial->group())
       sdch_supported_domain = "never_enabled_sdch_for_any_domain";
   }
 
   SdchManager sdch_manager;  // Singleton database.
   sdch_manager.set_sdch_fetcher(new SdchDictionaryFetcher);
   sdch_manager.EnableSdchSupport(sdch_supported_domain);
 
   MetricsService* metrics = InitializeMetrics(parsed_command_line, local_state);
   InstallJankometer(parsed_command_line);
@@ skipping 178 matching lines @@
 #if defined(OS_CHROMEOS)
   // To be precise, logout (browser shutdown) is not yet done, but the
   // remaining work is negligible, hence we say LogoutDone here.
   chromeos::BootTimesLoader::Get()->AddLogoutTimeMarker("LogoutDone",
                                                         false);
   chromeos::BootTimesLoader::Get()->WriteLogoutTimes();
 #endif
   TRACE_EVENT_END("BrowserMain", 0, 0);
   return result_code;
 }