Supporting command line argument to force field trials

chrome/browser/chrome_browser_main.cc

 // Copyright (c) 2012 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 574 matching lines @@
 #endif  // defined(OS_WIN)
 
   // Initialize FieldTrialList to support FieldTrials that use one-time
   // randomization. The client ID will be empty if the user has not opted
   // to send metrics.
   MetricsService* metrics = browser_process_->metrics_service();
   if (IsMetricsReportingEnabled())
     metrics->ForceClientIdCreation();  // Needed below.
   field_trial_list_.reset(new base::FieldTrialList(metrics->GetClientId()));
 
+  // Ensure any field trials specified on the command line are initialized.
+  // Also stop the metrics service so that we don't pollute UMA.
+#ifndef NDEBUG
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kForceFieldTestNameAndValue)) {
+    std::string persistent = command_line->GetSwitchValueASCII(
+        switches::kForceFieldTestNameAndValue);
+    bool ret = base::FieldTrialList::CreateTrialsFromString(persistent);
+    CHECK(ret) << "Invalid --" << switches::kForceFieldTestNameAndValue <<
+                  " list specified.";
+    metrics->Stop();
+  }
+#endif  // NDEBUG
+
   SetupFieldTrials(metrics->recording_active(),
                    local_state_->IsManagedPreference(
                        prefs::kMaxConnectionsPerProxy));
 
   // Initialize FieldTrialSynchronizer system. This is a singleton and is used
   // for posting tasks via base::Bind. Its deleted when it goes out of scope.
   // Even though base::Bind does AddRef and Release, the object will not be
   // deleted after the Task is executed.
   field_trial_synchronizer_ = new FieldTrialSynchronizer();
 }
 
 // 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 ChromeBrowserMainParts::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 default group.
-  scoped_refptr<base::FieldTrial> connect_trial(
-      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;
+  int connect_6 = -1;
+
+  // After June 30, 2011 builds, it will always be in default group.
+  scoped_refptr<base::FieldTrial> connect_trial(
+      base::FieldTrialList::GetFieldTrialInstance(
+          "ConnCountImpact", kConnectDivisor, "conn_count_6", &connect_6,
+          2011, 6, 30));
 
   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);
 
@@ skipping 24 matching lines @@
 // before we time it out. Since these are "unused" sockets, we won't retry the
 // connection and instead show an error to the user. So we need to be
 // conservative here. We've seen that some servers will close the socket after
 // as short as 10 seconds. See http://crbug.com/84313 for more details.
 void ChromeBrowserMainParts::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 default group.
+  int socket_timeout_10 = -1;
   scoped_refptr<base::FieldTrial> socket_timeout_trial(
-      new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor,
-          "idle_timeout_10", 2011, 6, 30));
-  const int socket_timeout_10 = socket_timeout_trial->kDefaultGroupNumber;
+      base::FieldTrialList::GetFieldTrialInstance(
+          "IdleSktToImpact", kIdleSocketTimeoutDivisor, "idle_timeout_10",
+          &socket_timeout_10, 2011, 6, 30));
 
   const int socket_timeout_5 =
       socket_timeout_trial->AppendGroup("idle_timeout_5",
                                         kSocketTimeoutProbability);
   const int socket_timeout_20 =
       socket_timeout_trial->AppendGroup("idle_timeout_20",
                                         kSocketTimeoutProbability);
 
   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(
         base::TimeDelta::FromSeconds(5));
   } else if (idle_to_trial_group == socket_timeout_10) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(
         base::TimeDelta::FromSeconds(10));
   } else if (idle_to_trial_group == socket_timeout_20) {
     net::ClientSocketPool::set_unused_idle_socket_timeout(
         base::TimeDelta::FromSeconds(20));
   } else {
     NOTREACHED();
   }
 }
 
 void ChromeBrowserMainParts::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 default group.
-  scoped_refptr<base::FieldTrial> proxy_connection_trial(
-      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;
+  int proxy_connections_32 = -1;
+
+  // After June 30, 2011 builds, it will always be in default group.
+  scoped_refptr<base::FieldTrial> proxy_connection_trial(
+      base::FieldTrialList::GetFieldTrialInstance(
+          "ProxyConnectionImpact", kProxyConnectionsDivisor,
+          "proxy_connections_32", &proxy_connections_32, 2011, 6, 30));
 
   // 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);
@@ skipping 37 matching lines @@
   } else if (parsed_command_line().HasSwitch(switches::kEnableNpnHttpOnly)) {
     net::HttpStreamFactory::EnableNpnHttpOnly();
   } else {
 #if !defined(OS_CHROMEOS)
     bool is_spdy_trial = false;
     const base::FieldTrial::Probability kSpdyDivisor = 100;
     base::FieldTrial::Probability npnhttp_probability = 5;
     base::FieldTrial::Probability flow_control_probability = 5;
     base::FieldTrial::Probability spdy3_probability = 0;
 
+    // NPN with spdy support is the default.
+    int npn_spdy_grp = -1;
+
     // After June 30, 2013 builds, it will always be in default group.
     scoped_refptr<base::FieldTrial> trial(
-        new base::FieldTrial(
-            "SpdyImpact", kSpdyDivisor, "npn_with_spdy", 2013, 6, 30));
-
-    // NPN with spdy support is the default.
-    int npn_spdy_grp = trial->kDefaultGroupNumber;
+        base::FieldTrialList::GetFieldTrialInstance(
+            "SpdyImpact", kSpdyDivisor, "npn_with_spdy", &npn_spdy_grp,
+            2013, 6, 30));
 
     // NPN with only http support, no spdy.
     int npn_http_grp = trial->AppendGroup("npn_with_http", npnhttp_probability);
 
     // NPN with http/1.1, spdy/2, spdy/2.1 and spdy/3 support.
     int spdy3_grp = trial->AppendGroup("spdy3", spdy3_probability);
 
     // NPN with http/1.1, spdy/2 and spdy/2.1 support.
     int flow_control_grp = trial->AppendGroup(
         "flow_control", flow_control_probability);
@@ skipping 23 matching lines @@
   // Setup SPDY CWND Field trial.
   const base::FieldTrial::Probability kSpdyCwndDivisor = 100;
   const base::FieldTrial::Probability kSpdyCwnd16 = 20;     // fixed at 16
   const base::FieldTrial::Probability kSpdyCwnd10 = 20;     // fixed at 10
   const base::FieldTrial::Probability kSpdyCwndMin16 = 20;  // no less than 16
   const base::FieldTrial::Probability kSpdyCwndMin10 = 20;  // no less than 10
 
   // After June 30, 2013 builds, it will always be in default group
   // (cwndDynamic).
   scoped_refptr<base::FieldTrial> trial(
-      new base::FieldTrial(
-          "SpdyCwnd", kSpdyCwndDivisor, "cwndDynamic", 2013, 6, 30));
+      base::FieldTrialList::GetFieldTrialInstance(
+          "SpdyCwnd", kSpdyCwndDivisor, "cwndDynamic", NULL, 2013, 6, 30));
 
   trial->AppendGroup("cwnd10", kSpdyCwnd10);
   trial->AppendGroup("cwnd16", kSpdyCwnd16);
   trial->AppendGroup("cwndMin16", kSpdyCwndMin16);
   trial->AppendGroup("cwndMin10", kSpdyCwndMin10);
 
   if (parsed_command_line().HasSwitch(switches::kMaxSpdyConcurrentStreams)) {
     int value = 0;
     base::StringToInt(parsed_command_line().GetSwitchValueASCII(
             switches::kMaxSpdyConcurrentStreams),
@@ skipping 15 matching lines @@
 
     const int policy_list[] = { 0, 1, 2 };
     VLOG(1) << "Setting socket_reuse_policy = " << policy;
     SetSocketReusePolicy(policy, policy_list, arraysize(policy_list));
     return;
   }
 
   const base::FieldTrial::Probability kWarmSocketDivisor = 100;
   const base::FieldTrial::Probability kWarmSocketProbability = 33;
 
+  // Default value is USE_LAST_ACCESSED_SOCKET.
+  int last_accessed_socket = -1;
+
   // After January 30, 2013 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> warmest_socket_trial(
-      new base::FieldTrial(
+      base::FieldTrialList::GetFieldTrialInstance(
           "WarmSocketImpact", kWarmSocketDivisor, "last_accessed_socket",
-          2013, 1, 30));
+          &last_accessed_socket, 2013, 1, 30));
 
-  // Default value is USE_LAST_ACCESSED_SOCKET.
-  const int last_accessed_socket = warmest_socket_trial->kDefaultGroupNumber;
   const int warmest_socket = warmest_socket_trial->AppendGroup(
       "warmest_socket", kWarmSocketProbability);
   const int warm_socket = warmest_socket_trial->AppendGroup(
       "warm_socket", kWarmSocketProbability);
 
   const int warmest_socket_trial_group = warmest_socket_trial->group();
 
   const int policy_list[] = { warmest_socket, warm_socket,
                               last_accessed_socket };
   SetSocketReusePolicy(warmest_socket_trial_group, policy_list,
                        arraysize(policy_list));
 }
 
 // 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 ChromeBrowserMainParts::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 default group.
+    int connect_backup_jobs_enabled = -1;
     scoped_refptr<base::FieldTrial> trial(
-        new base::FieldTrial("ConnnectBackupJobs",
-            kConnectBackupJobsDivisor, "ConnectBackupJobsEnabled", 2011, 6,
-                30));
-    const int connect_backup_jobs_enabled = trial->kDefaultGroupNumber;
+        base::FieldTrialList::GetFieldTrialInstance("ConnnectBackupJobs",
+            kConnectBackupJobsDivisor, "ConnectBackupJobsEnabled",
+            &connect_backup_jobs_enabled, 2011, 6, 30));
     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));
+      base::FieldTrialList::GetFieldTrialInstance(
+          "DnsImpact", kDivisor, "default_enabled_prefetch", NULL,
+          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.
@@ skipping 86 matching lines @@
   }
 }
 
 void ChromeBrowserMainParts::ComodoDNSExperimentFieldTrial() {
   // 100% probability of being in the experiment group until the timeout.
   const base::FieldTrial::Probability kDivisor = 1;
   const base::FieldTrial::Probability kProbability = 1;
 
   // After April 15, 2012 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> trial(
-      new base::FieldTrial("ComodoDNSExperiment", kDivisor,
-          "inactive", 2012, 4, 15));
+      base::FieldTrialList::GetFieldTrialInstance(
+          "ComodoDNSExperiment", kDivisor, "inactive", NULL, 2012, 4, 15));
 
   const int active = trial->AppendGroup("active", kProbability);
 
   if (trial->group() == active)
     ChromeNetworkDelegate::EnableComodoDNSExperiment();
 }
 
 // ChromeBrowserMainParts: |SetupMetricsAndFieldTrials()| related --------------
 
 void ChromeBrowserMainParts::SetupFieldTrials(bool metrics_recording_enabled,
@@ skipping 625 matching lines @@
     if (!sdch_enabled)
       net::SdchManager::EnableSdchSupport(false);
   }
   if (sdch_enabled) {
     // 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 March 31, 2012 builds, it will always be in default group.
+    int sdch_enabled_group = -1;
     scoped_refptr<base::FieldTrial> sdch_trial(
-        new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR, "global_enable_sdch",
-            2012, 3, 31));
-    int sdch_enabled_group = sdch_trial->kDefaultGroupNumber;
+        base::FieldTrialList::GetFieldTrialInstance(
+            "GlobalSdch", kSDCH_DIVISOR, "global_enable_sdch",
+            &sdch_enabled_group, 2012, 3, 31));
 
     sdch_trial->AppendGroup("global_disable_sdch",
                             kSDCH_DISABLE_PROBABILITY);
     if (sdch_enabled_group != sdch_trial->group())
       net::SdchManager::EnableSdchSupport(false);
   }
 
   if (parsed_command_line().HasSwitch(switches::kEnableWatchdog))
     InstallJankometer(parsed_command_line());
 
@@ skipping 272 matching lines @@
     if (base::win::GetVersion() <= base::win::VERSION_XP)
       uma_name += "_XP";
 
     uma_name += "_PreRead_";
     uma_name += pre_read_percentage;
     AddPreReadHistogramTime(uma_name.c_str(), time);
   }
 #endif
 #endif
 }