Create a new-installs-only uniformity trial.

chrome/browser/chrome_browser_field_trials.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_field_trials.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/auto_launch_trial.h"
 #include "chrome/browser/autocomplete/autocomplete_field_trial.h"
 #include "chrome/browser/chrome_gpu_util.h"
 #include "chrome/browser/google/google_util.h"
+#include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 #include "chrome/browser/ui/sync/one_click_signin_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/metrics/variations/variations_util.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/spdy/spdy_session.h"
 #include "ui/base/layout.h"
 
@@ skipping 44 matching lines @@
                                                     group_number));
   }
 
   // Now that all groups have been appended, call group() on the trial to
   // ensure that our trial is registered. This resolves an off-by-one issue
   // where the default group never gets chosen if we don't "use" the trial.
   const int chosen_group = trial->group();
   DVLOG(1) << "Chosen Group: " << chosen_group;
 }
 
+// Setup a 50% uniformity trial for new installs only. This is accomplished by
+// disabling the trial on clients that were installed before a specified date.
+void SetupNewInstallUniformityTrial(const base::Time& install_date) {
+  const base::Time::Exploded kStartDate = {
+    2012, 11, 0, 6,  // Nov 6, 2012
+    0, 0, 0, 0       // 00:00:00.000
+  };
+  scoped_refptr<base::FieldTrial> trial(
+      base::FieldTrialList::FactoryGetFieldTrial(
+          "UMA-New-Install-Uniformity-Trial", 100, "Disabled",
+          2015, 1, 1, NULL));
+  trial->UseOneTimeRandomization();
+  trial->AppendGroup("Control", 50);
+  trial->AppendGroup("Experiment", 50);
+  const base::Time start_date = base::Time::FromLocalExploded(kStartDate);
+  if (install_date < start_date)
+    trial->Disable();
+  else
+    trial->group();
+}
+
 void SetSocketReusePolicy(int warmest_socket_trial_group,
                           const int socket_policy[],
                           int num_groups) {
   const int* result = std::find(socket_policy, socket_policy + num_groups,
                                 warmest_socket_trial_group);
   DCHECK_NE(result, socket_policy + num_groups)
       << "Not a valid socket reuse policy group";
   net::SetSocketReusePolicy(result - socket_policy);
 }
 
 }  // namespace
 
 ChromeBrowserFieldTrials::ChromeBrowserFieldTrials(
     const CommandLine& parsed_command_line) :
         parsed_command_line_(parsed_command_line) {
 }
 
 ChromeBrowserFieldTrials::~ChromeBrowserFieldTrials() {
 }
 
-void ChromeBrowserFieldTrials::SetupFieldTrials() {
+void ChromeBrowserFieldTrials::SetupFieldTrials(
+    const base::Time& install_time) {
   prerender::ConfigurePrefetchAndPrerender(parsed_command_line_);
   SpdyFieldTrial();
   WarmConnectionFieldTrial();
   AutoLaunchChromeFieldTrial();
   gpu_util::InitializeCompositingFieldTrial();
-  SetupUniformityFieldTrials();
+  SetupUniformityFieldTrials(install_time);
   AutocompleteFieldTrial::Activate();
   DisableNewTabFieldTrialIfNecesssary();
   SetUpSafeBrowsingInterstitialFieldTrial();
   SetUpInfiniteCacheFieldTrial();
   SetUpCacheSensitivityAnalysisFieldTrial();
   WindowsOverlappedTCPReadsFieldTrial();
 #if defined(ENABLE_ONE_CLICK_SIGNIN)
   OneClickSigninHelper::InitializeFieldTrial();
 #endif
   InstantiateDynamicTrials();
@@ skipping 83 matching lines @@
   // Create a 100% field trial based on the brand code.
   if (auto_launch_trial::IsInExperimentGroup(brand)) {
     base::FieldTrialList::CreateFieldTrial(kAutoLaunchTrialName,
                                            kAutoLaunchTrialAutoLaunchGroup);
   } else if (auto_launch_trial::IsInControlGroup(brand)) {
     base::FieldTrialList::CreateFieldTrial(kAutoLaunchTrialName,
                                            kAutoLaunchTrialControlGroup);
   }
 }
 
-void ChromeBrowserFieldTrials::SetupUniformityFieldTrials() {
+void ChromeBrowserFieldTrials::SetupUniformityFieldTrials(
+    const base::Time& install_date) {
   // One field trial will be created for each entry in this array. The i'th
   // field trial will have |trial_sizes[i]| groups in it, including the default
   // group. Each group will have a probability of 1/|trial_sizes[i]|.
   const int num_trial_groups[] = { 100, 20, 10, 5, 2 };
 
   // Declare our variation ID bases along side this array so we can loop over it
   // and assign the IDs appropriately. So for example, the 1 percent experiments
   // should have a size of 100 (100/100 = 1).
   const chrome_variations::VariationID trial_base_ids[] = {
       chrome_variations::kUniformity1PercentBase,
       chrome_variations::kUniformity5PercentBase,
       chrome_variations::kUniformity10PercentBase,
       chrome_variations::kUniformity20PercentBase,
       chrome_variations::kUniformity50PercentBase
   };
 
   const std::string kOneTimeRandomizedTrialName =
       "UMA-Uniformity-Trial-%d-Percent";
   for (size_t i = 0; i < arraysize(num_trial_groups); ++i) {
     SetupSingleUniformityFieldTrial(true, kOneTimeRandomizedTrialName,
                                        trial_base_ids[i], num_trial_groups[i]);
   }
 
   // Setup a 5% session-randomized uniformity trial.
   const std::string kSessionRandomizedTrialName =
       "UMA-Session-Randomized-Uniformity-Trial-%d-Percent";
   SetupSingleUniformityFieldTrial(false, kSessionRandomizedTrialName,
       chrome_variations::kUniformitySessionRandomized5PercentBase, 20);
+
+  SetupNewInstallUniformityTrial(install_date);
 }
 
 void ChromeBrowserFieldTrials::DisableNewTabFieldTrialIfNecesssary() {
   // The new tab button field trial will get created in variations_service.cc
   // through the variations server. However, since there are no HiDPI assets
   // for it, disable it for non-desktop layouts.
   base::FieldTrial* trial = base::FieldTrialList::Find("NewTabButton");
   if (trial) {
     bool using_hidpi_assets = false;
 #if defined(ENABLE_HIDPI) && defined(OS_WIN)
@@ skipping 81 matching lines @@
 #endif
 }
 
 void ChromeBrowserFieldTrials::InstantiateDynamicTrials() {
   // Call |FindValue()| on the trials below, which may come from the server, to
   // ensure they get marked as "used" for the purposes of data reporting.
   base::FieldTrialList::FindValue("UMA-Dynamic-Binary-Uniformity-Trial");
   base::FieldTrialList::FindValue("UMA-Dynamic-Uniformity-Trial");
   base::FieldTrialList::FindValue("InstantDummy");
 }