Make three simultanious prerenders the default maximum in Canary and Dev only.

chrome/browser/prerender/prerender_field_trial.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/prerender/prerender_field_trial.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 
+using base::FieldTrial;
+using base::FieldTrialList;
+
 namespace prerender {
 
 namespace {
 
 const char kOmniboxTrialName[] = "PrerenderFromOmnibox";
 int g_omnibox_trial_default_group_number = kint32min;
 
 const char kSpeculativePrefetchingLearningTrialName[] =
     "SpeculativePrefetchingLearning";
 int g_speculative_prefetching_learning_default_group_number = kint32min;
 
 void SetupPrefetchFieldTrial() {
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     return;
   }
 
-  const base::FieldTrial::Probability divisor = 1000;
-  const base::FieldTrial::Probability prefetch_probability = 500;
-  scoped_refptr<base::FieldTrial> trial(
-      base::FieldTrialList::FactoryGetFieldTrial(
+  const FieldTrial::Probability divisor = 1000;
+  const FieldTrial::Probability prefetch_probability = 500;
+  scoped_refptr<FieldTrial> trial(
+      FieldTrialList::FactoryGetFieldTrial(
           "Prefetch", divisor, "ContentPrefetchPrefetchOff",
           2013, 6, 30, NULL));
   const int kPrefetchOnGroup = trial->AppendGroup("ContentPrefetchPrefetchOn",
                                                   prefetch_probability);
   PrerenderManager::SetIsPrefetchEnabled(trial->group() == kPrefetchOnGroup);
 }
 
 void SetupPrerenderFieldTrial() {
-  base::FieldTrial::Probability divisor = 1000;
+  const FieldTrial::Probability divisor = 1000;
 
-  base::FieldTrial::Probability exp1_probability = 166;
-  base::FieldTrial::Probability exp1_5min_ttl_probability = 83;
-  base::FieldTrial::Probability control1_probability = 166;
-  base::FieldTrial::Probability no_use1_probability = 83;
-
-  base::FieldTrial::Probability exp2_probability = 167;
-  base::FieldTrial::Probability exp2_5min_ttl_probability = 84;
-  base::FieldTrial::Probability control2_probability = 167;
-  base::FieldTrial::Probability no_use2_probability = 84;
+  FieldTrial::Probability prerender_on_probability;
+  FieldTrial::Probability control_probability;
+  FieldTrial::Probability experiment_multi_prerender_probability;
+  FieldTrial::Probability experiment_5min_ttl_probability;
+  FieldTrial::Probability experiment_no_use_probability;
 
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
-    exp1_probability = 490;
-    exp1_5min_ttl_probability = 5;
-    control1_probability = 5;
-    no_use1_probability = 0;
-    exp2_probability = 490;
-    exp2_5min_ttl_probability = 5;
-    control2_probability = 5;
-    no_use2_probability = 0;
+    // Use very conservatives and stable settings in beta and stable.
+    const FieldTrial::Probability release_prerender_on_probability = 980;
+    const FieldTrial::Probability release_control_probability = 10;
+    const FieldTrial::Probability
+        release_experiment_multi_prerender_probability = 0;
+    const FieldTrial::Probability release_experiment_5min_ttl_probability = 10;
+    const FieldTrial::Probability release_experiment_no_use_probability = 0;
+    COMPILE_ASSERT(
+        release_prerender_on_probability + release_control_probability +
+        release_experiment_multi_prerender_probability +
+        release_experiment_5min_ttl_probability +
+        release_experiment_no_use_probability == divisor,
+        release_experiment_probabilities_must_equal_divisor);
+
+    prerender_on_probability = release_prerender_on_probability;
+    control_probability = release_experiment_5min_ttl_probability;
+    experiment_multi_prerender_probability =
+        release_experiment_multi_prerender_probability;
+    experiment_5min_ttl_probability = release_control_probability;
+    experiment_no_use_probability = release_experiment_no_use_probability;
+  } else {
+    // In testing channels, use more experiments and a larger control group to
+    // improve quality of data.
+    const FieldTrial::Probability dev_prerender_on_probability = 250;
+    const FieldTrial::Probability dev_control_probability = 250;
+    const FieldTrial::Probability
+        dev_experiment_multi_prerender_probability = 250;
+    const FieldTrial::Probability dev_experiment_5min_ttl_probability = 125;
+    const FieldTrial::Probability dev_experiment_no_use_probability = 125;
+    COMPILE_ASSERT(dev_prerender_on_probability + dev_control_probability +
+                   dev_experiment_multi_prerender_probability +
+                   dev_experiment_5min_ttl_probability +
+                   dev_experiment_no_use_probability == divisor,
+                   dev_experiment_probabilities_must_equal_divisor);
+
+    prerender_on_probability = dev_prerender_on_probability;
+    control_probability = dev_experiment_5min_ttl_probability;
+    experiment_multi_prerender_probability =
+        dev_experiment_multi_prerender_probability;
+    experiment_5min_ttl_probability = dev_control_probability;
+    experiment_no_use_probability = dev_experiment_no_use_probability;
   }
-  CHECK_EQ(divisor, exp1_probability + exp1_5min_ttl_probability +
-           control1_probability + no_use1_probability + exp2_probability +
-           exp2_5min_ttl_probability + control2_probability +
-           no_use2_probability);
-  int experiment_1_group = -1;
-  scoped_refptr<base::FieldTrial> trial(
-      base::FieldTrialList::FactoryGetFieldTrial(
-          "Prerender", divisor, "ContentPrefetchPrerender1",
-          2013, 6, 30, &experiment_1_group));
 
-  const int experiment_15_min_TTL_group =
-      trial->AppendGroup("ContentPrefetchPrerenderExp5minTTL1",
-                         exp1_5min_ttl_probability);
-  const int control_1_group =
-      trial->AppendGroup("ContentPrefetchPrerenderControl1",
-                         control1_probability);
-  const int no_use_1_group =
-      trial->AppendGroup("ContentPrefetchPrerenderNoUse1",
-                         no_use1_probability);
-  const int experiment_2_group =
-      trial->AppendGroup("ContentPrefetchPrerender2",
-                         exp2_probability);
-  const int experiment_25_min_TTL_group =
-      trial->AppendGroup("ContentPrefetchPrerenderExp5minTTL2",
-                         exp2_5min_ttl_probability);
-  const int control_2_group =
-      trial->AppendGroup("ContentPrefetchPrerenderControl2",
-                         control2_probability);
-  const int no_use_2_group =
-      trial->AppendGroup("ContentPrefetchPrerenderNoUse2",
-                         no_use2_probability);
+  int prerender_on_group = -1;
+  scoped_refptr<FieldTrial> trial(
+      FieldTrialList::FactoryGetFieldTrial(
+          "Prerender", divisor, "PrerenderEnabled",
+          2013, 6, 30, &prerender_on_group));
+  const int control_group =
+      trial->AppendGroup("PrerenderControl",
+                         control_probability);
+  const int experiment_multi_prerender_group =
+      trial->AppendGroup("PrerenderMulti",
+                         experiment_multi_prerender_probability);
+  const int experiment_5_min_TTL_group =
+      trial->AppendGroup("Prerender5minTTL",
+                         experiment_5min_ttl_probability);
+  const int experiment_no_use_group =
+      trial->AppendGroup("PrerenderNoUse",
+                         experiment_no_use_probability);
+
   const int trial_group = trial->group();
-  if (trial_group == experiment_1_group ||
-      trial_group == experiment_2_group) {
+  if (trial_group == prerender_on_group) {
     PrerenderManager::SetMode(
         PrerenderManager::PRERENDER_MODE_EXPERIMENT_PRERENDER_GROUP);
-  } else if (trial_group == experiment_15_min_TTL_group ||
-             trial_group == experiment_25_min_TTL_group) {
+  } else if (trial_group == control_group) {
+    PrerenderManager::SetMode(
+        PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
+  } else if (trial_group == experiment_multi_prerender_group) {
+    PrerenderManager::SetMode(
+        PrerenderManager::PRERENDER_MODE_EXPERIMENT_MULTI_PRERENDER_GROUP);
+  } else if (trial_group == experiment_5_min_TTL_group) {
     PrerenderManager::SetMode(
         PrerenderManager::PRERENDER_MODE_EXPERIMENT_5MIN_TTL_GROUP);
-  } else if (trial_group == control_1_group ||
-             trial_group == control_2_group) {
-    PrerenderManager::SetMode(
-        PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
-  } else if (trial_group == no_use_1_group ||
-             trial_group == no_use_2_group) {
+  } else if (trial_group == experiment_no_use_group) {
     PrerenderManager::SetMode(
         PrerenderManager::PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP);
   } else {
     NOTREACHED();
   }
 }
 
 }  // end namespace
 
 void ConfigureOmniboxPrerender();
@@ skipping 56 matching lines @@
   UMA_HISTOGRAM_ENUMERATION("Prerender.Sessions",
                             PrerenderManager::GetMode(),
                             PrerenderManager::PRERENDER_MODE_MAX);
 
   ConfigureOmniboxPrerender();
   ConfigureSpeculativePrefetching();
 }
 
 void ConfigureOmniboxPrerender() {
   // Field trial to see if we're enabled.
-  const base::FieldTrial::Probability kDivisor = 100;
+  const FieldTrial::Probability kDivisor = 100;
 
-  base::FieldTrial::Probability kDisabledProbability = 10;
+  FieldTrial::Probability kDisabledProbability = 10;
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     kDisabledProbability = 1;
   }
-  scoped_refptr<base::FieldTrial> omnibox_prerender_trial(
-      base::FieldTrialList::FactoryGetFieldTrial(
+  scoped_refptr<FieldTrial> omnibox_prerender_trial(
+      FieldTrialList::FactoryGetFieldTrial(
           kOmniboxTrialName, kDivisor, "OmniboxPrerenderEnabled",
           2012, 12, 30, &g_omnibox_trial_default_group_number));
   omnibox_prerender_trial->AppendGroup("OmniboxPrerenderDisabled",
                                        kDisabledProbability);
 }
 
 bool IsOmniboxEnabled(Profile* profile) {
   if (!profile)
     return false;
 
   if (!PrerenderManager::IsPrerenderingPossible())
     return false;
 
   // Override any field trial groups if the user has set a command line flag.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kPrerenderFromOmnibox)) {
     const std::string switch_value =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kPrerenderFromOmnibox);
 
     if (switch_value == switches::kPrerenderFromOmniboxSwitchValueEnabled)
       return true;
 
     if (switch_value == switches::kPrerenderFromOmniboxSwitchValueDisabled)
       return false;
 
     DCHECK(switch_value == switches::kPrerenderFromOmniboxSwitchValueAuto);
   }
 
-  const int group = base::FieldTrialList::FindValue(kOmniboxTrialName);
-  return group == base::FieldTrial::kNotFinalized ||
+  const int group = FieldTrialList::FindValue(kOmniboxTrialName);
+  return group == FieldTrial::kNotFinalized ||
          group == g_omnibox_trial_default_group_number;
 }
 
 void ConfigureSpeculativePrefetching() {
   // Field trial to see if we're enabled.
-  const base::FieldTrial::Probability kDivisor = 100;
+  const FieldTrial::Probability kDivisor = 100;
 
-  base::FieldTrial::Probability kDisabledProbability = 99;
+  FieldTrial::Probability kDisabledProbability = 99;
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     kDisabledProbability = 100;
   }
-  scoped_refptr<base::FieldTrial> speculative_prefetching_learning_trial(
-      base::FieldTrialList::FactoryGetFieldTrial(
+  scoped_refptr<FieldTrial> speculative_prefetching_learning_trial(
+      FieldTrialList::FactoryGetFieldTrial(
           kSpeculativePrefetchingLearningTrialName,
           kDivisor,
           "SpeculativePrefetchingLearningEnabled",
           2012, 12, 30,
           &g_speculative_prefetching_learning_default_group_number));
   speculative_prefetching_learning_trial->AppendGroup(
       "SpeculativePrefetchingDisabled",
       kDisabledProbability);
 }
 
 bool IsSpeculativeResourcePrefetchingLearningEnabled(Profile* profile) {
   if (!profile)
     return false;
 
   // Override any field trial groups if the user has set a command line flag.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSpeculativeResourcePrefetching)) {
     const std::string switch_value =
         CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kSpeculativeResourcePrefetching);
 
     if (switch_value == switches::kSpeculativeResourcePrefetchingLearning)
       return true;
   }
 
-  const int group = base::FieldTrialList::FindValue(
+  const int group = FieldTrialList::FindValue(
       kSpeculativePrefetchingLearningTrialName);
   return group == g_speculative_prefetching_learning_default_group_number;
 }
 
 }  // namespace prerender