Do conservative prerendering based on the LocalPredictor in Dev/Canary.

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"
@@ skipping 10 matching lines @@
 
 namespace prerender {
 
 namespace {
 
 const char kOmniboxTrialName[] = "PrerenderFromOmnibox";
 int g_omnibox_trial_default_group_number = kint32min;
 
 const char kLocalPredictorTrialName[] = "PrerenderLocalPredictor";
 const char kLocalPredictorEnabledGroup[] = "Enabled";
+const char kLocalPredictorDisabledGroup[] = "Disabled";
 
 const char kLoggedInPredictorTrialName[] = "PrerenderLoggedInPredictor";
 const char kLoggedInPredictorEnabledGroup[] = "Enabled";
 const char kLoggedInPredictorDisabledGroup[] = "Disabled";
 
 const char kSideEffectFreeWhitelistTrialName[] = "SideEffectFreeWhitelist";
 const char kSideEffectFreeWhitelistEnabledGroup[] = "Enabled";
 const char kSideEffectFreeWhitelistDisabledGroup[] = "Disabled";
 
 void SetupPrefetchFieldTrial() {
@@ skipping 101 matching lines @@
     PrerenderManager::SetMode(
         PrerenderManager::PRERENDER_MODE_EXPERIMENT_NO_USE_GROUP);
   } else {
     NOTREACHED();
   }
 }
 
 }  // end namespace
 
 void ConfigureOmniboxPrerender();
+void ConfigureLocalPredictor();
 void ConfigureLoggedInPredictor();
 void ConfigureSideEffectFreeWhitelist();
 
 void ConfigurePrefetchAndPrerender(const CommandLine& command_line) {
   enum PrerenderOption {
     PRERENDER_OPTION_AUTO,
     PRERENDER_OPTION_DISABLED,
     PRERENDER_OPTION_ENABLED,
     PRERENDER_OPTION_PREFETCH_ONLY,
   };
@@ skipping 38 matching lines @@
       break;
     case PRERENDER_OPTION_PREFETCH_ONLY:
       PrerenderManager::SetIsPrefetchEnabled(true);
       PrerenderManager::SetMode(PrerenderManager::PRERENDER_MODE_DISABLED);
       break;
     default:
       NOTREACHED();
   }
 
   ConfigureOmniboxPrerender();
+  ConfigureLocalPredictor();
   ConfigureLoggedInPredictor();
   ConfigureSideEffectFreeWhitelist();
 }
 
 void ConfigureOmniboxPrerender() {
   // Field trial to see if we're enabled.
   const FieldTrial::Probability kDivisor = 100;
 
   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<FieldTrial> omnibox_prerender_trial(
       FieldTrialList::FactoryGetFieldTrial(
           kOmniboxTrialName, kDivisor, "OmniboxPrerenderEnabled",
           2013, 12, 31, &g_omnibox_trial_default_group_number));
   omnibox_prerender_trial->AppendGroup("OmniboxPrerenderDisabled",
                                        kDisabledProbability);
 }
 
+void ConfigureLocalPredictor() {
+  chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
+  if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
+      channel == chrome::VersionInfo::CHANNEL_BETA) {
+    return;
+  }
+  scoped_refptr<FieldTrial> local_predictor_trial(
+      FieldTrialList::FactoryGetFieldTrial(
+          kLocalPredictorTrialName, 100,
+          kLocalPredictorDisabledGroup, 2013, 12, 31, NULL));
+  local_predictor_trial->AppendGroup(kLocalPredictorEnabledGroup, 100);
+}
+
 void ConfigureLoggedInPredictor() {
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     return;
   }
   scoped_refptr<FieldTrial> logged_in_predictor_trial(
       FieldTrialList::FactoryGetFieldTrial(
           kLoggedInPredictorTrialName, 100,
           kLoggedInPredictorDisabledGroup, 2013, 12, 31, NULL));
   logged_in_predictor_trial->AppendGroup(kLoggedInPredictorEnabledGroup, 100);
 }
 
 void ConfigureSideEffectFreeWhitelist() {
   scoped_refptr<FieldTrial> side_effect_free_whitelist_trial(
       FieldTrialList::FactoryGetFieldTrial(
           kSideEffectFreeWhitelistTrialName, 100,
           kSideEffectFreeWhitelistDisabledGroup, 2013, 12, 31, NULL));
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     return;
   }
   side_effect_free_whitelist_trial->AppendGroup(
-      kSideEffectFreeWhitelistEnabledGroup, 100);
+      kSideEffectFreeWhitelistEnabledGroup, 0);
 }
 
 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.
@@ skipping 11 matching lines @@
 
     DCHECK(switch_value == switches::kPrerenderFromOmniboxSwitchValueAuto);
   }
 
   const int group = FieldTrialList::FindValue(kOmniboxTrialName);
   return group == FieldTrial::kNotFinalized ||
          group == g_omnibox_trial_default_group_number;
 }
 
 bool IsLocalPredictorEnabled() {
+#if defined(OS_ANDROID) || defined(OS_IOS)
+  return false;
+#endif
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisablePrerenderLocalPredictor)) {
+    return false;
+  }
   return base::FieldTrialList::FindFullName(kLocalPredictorTrialName) ==
       kLocalPredictorEnabledGroup;
 }
 
 bool IsLoggedInPredictorEnabled() {
   return base::FieldTrialList::FindFullName(kLoggedInPredictorTrialName) ==
       kLoggedInPredictorEnabledGroup;
 }
 
 bool IsSideEffectFreeWhitelistEnabled() {
   return base::FieldTrialList::FindFullName(kSideEffectFreeWhitelistTrialName)
       == kSideEffectFreeWhitelistEnabledGroup;
 }
 
 }  // namespace prerender