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

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 "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"
 #include "chrome/browser/sync/profile_sync_service.h"
 #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"
 
 using base::FieldTrial;
 using base::FieldTrialList;
 using base::StringToInt;
 using std::string;
 using std::vector;
 
 namespace prerender {
 
 namespace {
 
 const char kOmniboxTrialName[] = "PrerenderFromOmnibox";
 int g_omnibox_trial_default_group_number = kint32min;
 
 const char kDisabledGroup[] = "Disabled";
 const char kEnabledGroup[] = "Enabled";
 
 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";
 const char kPrerenderPrefetchKeyName[] = "PrerenderPrefetch";
 const char kPrerenderQueryPrerenderServiceKeyName[] =
     "PrerenderQueryPrerenderService";
 const char kPrerenderQueryPrerenderServiceCurrentURLKeyName[] =
     "PrerenderQueryPrerenderServiceCurrentURL";
 const char kPrerenderQueryPrerenderServiceCandidateURLsKeyName[] =
     "PrerenderQueryPrerenderServiceCandidateURLs";
@@ skipping 270 matching lines @@
 bool IsLocalPredictorEnabled() {
 #if defined(OS_ANDROID) || defined(OS_IOS)
   return false;
 #endif
   return
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePrerenderLocalPredictor) &&
       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();
 }
 
 bool IsSideEffectFreeWhitelistEnabled() {
   return IsLocalPredictorEnabled() &&
       GetLocalPredictorSpecValue(kSideEffectFreeWhitelistKeyName) !=
       kDisabledGroup;
 }
 
@@ skipping 132 matching lines @@
   return GetLocalPredictorSpecValue(kDisableSessionStorageNamespaceMerging) !=
       kDisabledGroup;
 }
 
 bool IsPrerenderCookieStoreEnabled() {
   return GetLocalPredictorSpecValue(kPrerenderCookieStore) != kDisabledGroup &&
       FieldTrialList::FindFullName(kPrerenderCookieStore) != kDisabledGroup;
 }
 
 }  // namespace prerender