Provide a way to specify in Finch trials to disable prerender local

chrome/browser/prerender/prerender_field_trial.cc

Index: chrome/browser/prerender/prerender_field_trial.cc
diff --git a/chrome/browser/prerender/prerender_field_trial.cc b/chrome/browser/prerender/prerender_field_trial.cc
index 4dbac4be74a3efbd6bbffb2ba72993ce1cf76605..e47c767c4b2df22536a56aa629d90093b1c6ae24 100644
--- a/chrome/browser/prerender/prerender_field_trial.cc
+++ b/chrome/browser/prerender/prerender_field_trial.cc
@@ -11,6 +11,7 @@
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/profiles/profile.h"
@@ -18,6 +19,7 @@
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
+#include "chrome/common/pref_names.h"
 #include "components/metrics/metrics_service.h"
 #include "components/variations/variations_associated_data.h"
 
@@ -41,6 +43,9 @@ const char kLocalPredictorSpecTrialName[] = "PrerenderLocalPredictorSpec";
 const char kLocalPredictorKeyName[] = "LocalPredictor";
 const char kLocalPredictorUnencryptedSyncOnlyKeyName[] =
     "LocalPredictorUnencryptedSyncOnly";
+const char kLocalPredictorNetworkPredictionEnabledOnly[] =
+    "LocalPredictorNetworkPredictionEnabledOnly";
+const char kLocalPredictorOnCellularOnly[] = "LocalPredictorOnCellularOnly";
 const char kSideEffectFreeWhitelistKeyName[] = "SideEffectFreeWhitelist";
 const char kPrerenderLaunchKeyName[] = "PrerenderLaunch";
 const char kPrerenderAlwaysControlKeyName[] = "PrerenderAlwaysControl";
@@ -331,13 +336,38 @@ bool IsLocalPredictorEnabled() {
       GetLocalPredictorSpecValue(kLocalPredictorKeyName) == kEnabledGroup;
 }
 
-bool DisableLocalPredictorBasedOnSyncAndConfiguration(Profile* profile) {
+bool ShouldDisableLocalPredictorBasedOnSyncAndConfiguration(Profile* profile) {
   return
       GetLocalPredictorSpecValue(kLocalPredictorUnencryptedSyncOnlyKeyName) ==
           kEnabledGroup &&
       !IsUnencryptedSyncEnabled(profile);
 }
 
+bool ShouldDisableLocalPredictorDueToPreferencesAndNetwork(Profile* profile) {
+  bool on_cellular =
+      net::NetworkChangeNotifier::IsConnectionCellular(
+          net::NetworkChangeNotifier::GetConnectionType());
+  // If the user is not on a cellular connection, but we require a cellular
+  // connection, we must temporarily disable our local predictions.
+  if (!on_cellular &&
+      GetLocalPredictorSpecValue(kLocalPredictorOnCellularOnly) ==
+      kEnabledGroup) {
+    return true;
+  }
+
+  // If we don't care whether or not network prediction will actually be
+  // exercised, we do not need to temporarily disable our predictions.
+  if (GetLocalPredictorSpecValue(kLocalPredictorNetworkPredictionEnabledOnly) !=
+      kEnabledGroup) {
+    return false;
+  }
+
+  // We should temporarily disable iff the predictive network action would
+  // not be exercised.
+
+  return !chrome_browser_net::CanPrefetchAndPrerenderUI(profile->GetPrefs());

[Zhen Wang, 2014/09/24 16:33:58]

Should we check CanPrefetchAndPrerenderUI() first?

Say the following case:
- CanPrefetchAndPrerenderUI() is false
- kLocalPredictorNetworkPredictionEnabledOnly != enabled

The function should return true. But the check on
kLocalPredictorNetworkPredictionEnabledOnly will return false beforehand.

I don't seen any other function using CanPrefetchAndPrerenderUI(). Should we
actually check this for all prefetch/prerender experiments?

[tburkard, 2014/09/25 14:21:37]

Actually, the idea is that it should return false in this case. If
kLocalPredictorNetworkPredictionEnabledOnly != enabled, you don't care whether
it is enabled or not.

So you don't need to disable the local predictor.

Basically, the two options, NPEO (network prediction enabled only) and OCO (on
cellular only) can be combined as follows:

- neither: always proceed and issue local predictor pre*
- OCO: only issue local predictor pre* if we are on cellular, but irrespective
of whether the actual pre* action will succeed or not
- NPEO: only issue the local predictor pre* if it will actually succeed, but
irrespective if we are on cellular or not.
- OCO+NPEO: only issue local predictor pre* if it will actually succeed, AND if
we are on cellular

This allows us to do three things:
If we don't care about the actual issuance (eg to collect stats of how often it
would trigger etc), use neither.
If we want stats without caring about the actual issuance, but cellular only,
use OCO.
If we want stats on the benefits of when it was actually issued, for both wifi
and cellular, use NPEO
If we want stats on the benefits of when it wsa actually issued, but limited to
cellular (so that we can present the benefit we bring to cellar users), use
OCO+NPEO

Does this make sense?

If you see any missing scenarios not covered by this, please let me know!
No, because in tests, the default is that it's enabled. Only actual users
disable it sometimes, which is what we are testing here.

+}
+
 bool IsLoggedInPredictorEnabled() {
   return IsLocalPredictorEnabled();
 }