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.

[jar (doing other things), 2012/04/06 01:41:29]

I'm not sure on the ordering, but disabling UMA is probably better done around
line 1095.  You might need to separate the setting of field trials, from the
control of UMA as well.

[MAD, 2012/04/11 02:38:08]

Done.

+#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 29 matching lines @@
     return;
   }
 
   if (IsMetricsReportingEnabled())
     metrics->Start();
 }
 
 bool ChromeBrowserMainParts::IsMetricsReportingEnabled() {
   // If the user permits metrics reporting with the checkbox in the
   // prefs, we turn on recording.  We disable metrics completely for
   // non-official builds.

[jar (doing other things), 2012/04/06 01:41:29]

This is probably a better place to control (disable) UMA, since that is what
this code is all about (so the flow is guaranteed to work as expected... I
think).

[MAD, 2012/04/11 02:38:08]

Done.

   bool enabled = false;
 #if defined(GOOGLE_CHROME_BUILD)
 #if defined(OS_CHROMEOS)
   chromeos::CrosSettings::Get()->GetBoolean(chromeos::kStatsReportingPref,
                                             &enabled);
 #else
   enabled = local_state_->GetBoolean(prefs::kMetricsReportingEnabled);
 #endif  // #if defined(OS_CHROMEOS)
 #endif  // defined(GOOGLE_CHROME_BUILD)
   return enabled;
@@ skipping 575 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
 }