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) {

[jkarlin, 2014/09/23 14:54:03]

This should also be "ShouldDisableLocalPredictor..."

[tburkard, 2014/09/24 15:15:34]

Done.

   return
       GetLocalPredictorSpecValue(kLocalPredictorUnencryptedSyncOnlyKeyName) ==
           kEnabledGroup &&
       !IsUnencryptedSyncEnabled(profile);
 }
 
+bool TemporarilyDisableLocalPredictorBasedOnPreferencesAndNetwork(
+    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 (GetLocalPredictorSpecValue(kLocalPredictorOnCellularOnly) ==
+      kEnabledGroup && !on_cellular) {

[jkarlin, 2014/09/23 14:54:03]

Put !on_cellular first in the conditional since it's faster.

[tburkard, 2014/09/24 15:15:34]

Done.

+    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.
+
+  int network_prediction_preference =

[jkarlin, 2014/09/23 14:54:03]

Can you replace lines 368 and below with:

return !chrome_browser_net::CanPrefetchAndPrerenderUI(profile->GetPrefs());

?

[tburkard, 2014/09/24 15:15:34]

Done.

+      profile->GetPrefs()->GetInteger(prefs::kNetworkPredictionOptions);
+
+  // If the user has network predictions never selected, we must disable
+  // predictions.
+  if (network_prediction_preference ==
+      chrome_browser_net::NETWORK_PREDICTION_NEVER) {
+    return true;
+  }
+
+  // If the user has network predictions enabled on wifi only, but we are
+  // on cellular, any predictive actions would not be exercised, so we
+  // must disable predictions.
+  if (network_prediction_preference ==
+      chrome_browser_net::NETWORK_PREDICTION_WIFI_ONLY && on_cellular) {
+    return true;
+  }
+
+  // In all other cases, network predictions will be exercised, so it is ok
+  // to proceed.
+
+  return false;
+}
+
 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