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 599 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
+  // and 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(
+      base::FieldTrial::CreateInstance(
           "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);
@@ skipping 32 matching lines @@
 // 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.
   scoped_refptr<base::FieldTrial> socket_timeout_trial(
-      new base::FieldTrial("IdleSktToImpact", kIdleSocketTimeoutDivisor,
-          "idle_timeout_10", 2011, 6, 30));
+      base::FieldTrial::CreateInstance(
+          "IdleSktToImpact", kIdleSocketTimeoutDivisor, "idle_timeout_10",
+          2011, 6, 30));
   const int socket_timeout_10 = socket_timeout_trial->kDefaultGroupNumber;
 
   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();
@@ skipping 12 matching lines @@
   }
 }
 
 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,
+      base::FieldTrial::CreateInstance(
+          "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
@@ skipping 33 matching lines @@
     std::string spdy_mode =
         parsed_command_line().GetSwitchValueASCII(switches::kUseSpdy);
     net::HttpNetworkLayer::EnableSpdy(spdy_mode);
   } else {
 #if !defined(OS_CHROMEOS)
     bool is_spdy_trial = false;
     const base::FieldTrial::Probability kSpdyDivisor = 100;
     base::FieldTrial::Probability npnhttp_probability = 5;
 
     // 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));
+    scoped_refptr<base::FieldTrial> trial(base::FieldTrial::CreateInstance(
+        "SpdyImpact", kSpdyDivisor, "npn_with_spdy", 2013, 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);
 
     int trial_grp = trial->group();
     if (trial_grp == npn_http_grp) {
       is_spdy_trial = true;
@@ skipping 12 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));
+  scoped_refptr<base::FieldTrial> trial(base::FieldTrial::CreateInstance(
+      "SpdyCwnd", kSpdyCwndDivisor, "cwndDynamic", 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 17 matching lines @@
     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;
 
   // After January 30, 2013 builds, it will always be in default group.
   scoped_refptr<base::FieldTrial> warmest_socket_trial(
-      new base::FieldTrial(
+      base::FieldTrial::CreateInstance(
           "WarmSocketImpact", kWarmSocketDivisor, "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);
 
@@ skipping 15 matching lines @@
   } 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.
     scoped_refptr<base::FieldTrial> trial(
-        new base::FieldTrial("ConnnectBackupJobs",
+        base::FieldTrial::CreateInstance("ConnnectBackupJobs",
             kConnectBackupJobsDivisor, "ConnectBackupJobsEnabled", 2011, 6,
                 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));
+  scoped_refptr<base::FieldTrial> trial(base::FieldTrial::CreateInstance(
+      "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.
@@ 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,
+      base::FieldTrial::CreateInstance("ComodoDNSExperiment", kDivisor,
           "inactive", 2012, 4, 15));
 
   const int active = trial->AppendGroup("active", kProbability);
 
   if (trial->group() == active)
     ChromeNetworkDelegate::EnableComodoDNSExperiment();
 }
 
 // ChromeBrowserMainParts: |SetupMetricsAndFieldTrials()| related --------------
 
@@ skipping 640 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.
-    scoped_refptr<base::FieldTrial> sdch_trial(
-        new base::FieldTrial("GlobalSdch", kSDCH_DIVISOR, "global_enable_sdch",
-            2012, 3, 31));
+    scoped_refptr<base::FieldTrial> sdch_trial(base::FieldTrial::CreateInstance(
+        "GlobalSdch", kSDCH_DIVISOR, "global_enable_sdch", 2012, 3, 31));
     int sdch_enabled_group = sdch_trial->kDefaultGroupNumber;
 
     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 271 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
 }