Integrate the LocalPredictor with the Prerender Service.

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/metrics/metrics_service.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"
 
 using base::FieldTrial;
 using base::FieldTrialList;
 using base::SplitStringUsingSubstr;
 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 kSideEffectFreeWhitelistKeyName[] = "SideEffectFreeWhitelist";
 const char kPrerenderLaunchKeyName[] = "PrerenderLaunch";
 const char kPrerenderAlwaysControlKeyName[] = "PrerenderAlwaysControl";
+const char kPrerenderQueryPrerenderServiceKeyName[] =
+    "PrerenderQueryPrerenderService";
+const char kPrerenderServiceBehaviorIDKeyName[] = "PrerenderServiceBehaviorID";
+const char kPrerenderServiceFetchTimeoutKeyName[] =
+    "PrerenderServiceFetchTimeoutMs";
 const char kPrerenderTTLKeyName[] = "PrerenderTTLSeconds";
 const char kPrerenderPriorityHalfLifeTimeKeyName[] =
     "PrerenderPriorityHalfLifeTimeSeconds";
 const char kMaxConcurrentPrerenderKeyName[] = "MaxConcurrentPrerenders";
 const char kSkipFragment[] = "SkipFragment";
 const char kSkipHTTPS[] = "SkipHTTPS";
 const char kSkipWhitelist[] = "SkipWhitelist";
+const char kSkipServiceWhitelist[] = "SkipServiceWhitelist";
 const char kSkipLoggedIn[] = "SkipLoggedIn";
 const char kSkipDefaultNoPrerender[] = "SkipDefaultNoPrerender";
+const char kLocalPredictorServiceURLPrefixTrialName[] =
+    "PrerenderLocalPredictorServiceURLPrefix";
+const char kDefaultPrerenderServiceURLPrefix[] =
+    "https://clients4.google.com/prerenderservice/?q=";
+const int kMinPrerenderServiceTimeoutMs = 1;
+const int kMaxPrerenderServiceTimeoutMs = 10000;
+const int kDefaultPrerenderServiceTimeoutMs = 1000;
 
 void SetupPrefetchFieldTrial() {
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     return;
   }
 
   const FieldTrial::Probability divisor = 1000;
   const FieldTrial::Probability prefetch_probability = 500;
@@ skipping 222 matching lines @@
       &elements);
   for (int i = 0; i < static_cast<int>(elements.size()); i++) {
     vector<string> key_value;
     SplitStringUsingSubstr(elements[i], "=", &key_value);
     if (key_value.size() == 2 && key_value[0] == spec_key)
       return key_value[1];
   }
   return string();
 }
 
-bool IsLocalPredictorEnabled() {
+bool IsUnencryptedSyncEnabled(Profile* profile) {
+  ProfileSyncService* service = ProfileSyncServiceFactory::GetInstance()->
+      GetForProfile(profile);
+  return service && service->GetSessionModelAssociator() &&
+      !service->EncryptEverythingEnabled();
+}
+
+// Indicates whether the Local Predictor is enabled based on field trial
+// selection.
+bool IsLocalPredictorEnabledBasedOnSelection() {
 #if defined(OS_ANDROID) || defined(OS_IOS)
   return false;
 #endif
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePrerenderLocalPredictor)) {
     return false;
   }
   return GetLocalPredictorSpecValue(kLocalPredictorKeyName) == kEnabledGroup;
 }
 
+// Usually, we enable the Local Predictor based on field trial selection
+// (see above), so we can just return that setting.
+// However, via Finch, we can specify to not create a LocalPredictor if
+// UnencryptedSync is not enabled. Therefore, we have to perform this additional
+// check to determine whether or not we actually want to enable the
+// LocalPredictor.
+bool IsLocalPredictorEnabled(Profile* profile) {
+  if (GetLocalPredictorSpecValue(kLocalPredictorUnencryptedSyncOnlyKeyName) ==
+      kEnabledGroup &&
+      !IsUnencryptedSyncEnabled(profile)) {
+    return false;
+  }
+  return IsLocalPredictorEnabledBasedOnSelection();
+}
+
 bool IsLoggedInPredictorEnabled() {
-  return IsLocalPredictorEnabled();
+  return IsLocalPredictorEnabledBasedOnSelection();
 }
 
 bool IsSideEffectFreeWhitelistEnabled() {
-  return IsLocalPredictorEnabled() &&
+  return IsLocalPredictorEnabledBasedOnSelection() &&
       GetLocalPredictorSpecValue(kSideEffectFreeWhitelistKeyName) !=
       kDisabledGroup;
 }
 
 bool IsLocalPredictorPrerenderLaunchEnabled() {
   return GetLocalPredictorSpecValue(kPrerenderLaunchKeyName) != kDisabledGroup;
 }
 
 bool IsLocalPredictorPrerenderAlwaysControlEnabled() {
   return GetLocalPredictorSpecValue(kPrerenderAlwaysControlKeyName) ==
       kEnabledGroup;
 }
 
+bool ShouldQueryPrerenderService(Profile* profile) {
+  return IsUnencryptedSyncEnabled(profile) &&
+      GetLocalPredictorSpecValue(kPrerenderQueryPrerenderServiceKeyName) ==
+      kEnabledGroup;
+}
+
+string GetPrerenderServiceURLPrefix() {
+  string prefix =
+      FieldTrialList::FindFullName(kLocalPredictorServiceURLPrefixTrialName);
+  if (prefix.empty())
+    prefix = kDefaultPrerenderServiceURLPrefix;
+  return prefix;
+}
+
+int GetPrerenderServiceBehaviorID() {
+  int id;
+  StringToInt(GetLocalPredictorSpecValue(kPrerenderServiceBehaviorIDKeyName),
+              &id);
+  // The behavior ID must be non-negative.
+  if (id < 0)
+    id = 0;
+  return id;
+}
+
+int GetPrerenderServiceFetchTimeoutMs() {
+  int result;
+  StringToInt(GetLocalPredictorSpecValue(kPrerenderServiceFetchTimeoutKeyName),
+              &result);
+  // The behavior ID must be non-negative.
+  if (result < kMinPrerenderServiceTimeoutMs ||
+      result > kMaxPrerenderServiceTimeoutMs) {
+    result = kDefaultPrerenderServiceTimeoutMs;
+  }
+  return result;
+}
+
 int GetLocalPredictorTTLSeconds() {
   int ttl;
   StringToInt(GetLocalPredictorSpecValue(kPrerenderTTLKeyName), &ttl);
   // If the value is outside of 10s or 600s, use a default value of 180s.
   if (ttl < 10 || ttl > 600)
     ttl = 180;
   return ttl;
 }
 
 int GetLocalPredictorPrerenderPriorityHalfLifeTimeSeconds() {
@@ skipping 24 matching lines @@
 }
 
 bool SkipLocalPredictorHTTPS() {
   return GetLocalPredictorSpecValue(kSkipHTTPS) == kEnabledGroup;
 }
 
 bool SkipLocalPredictorWhitelist() {
   return GetLocalPredictorSpecValue(kSkipWhitelist) == kEnabledGroup;
 }
 
+bool SkipLocalPredictorServiceWhitelist() {
+  return GetLocalPredictorSpecValue(kSkipServiceWhitelist) == kEnabledGroup;
+}
+
 bool SkipLocalPredictorLoggedIn() {
   return GetLocalPredictorSpecValue(kSkipLoggedIn) == kEnabledGroup;
 }
 
 bool SkipLocalPredictorDefaultNoPrerender() {
   return GetLocalPredictorSpecValue(kSkipDefaultNoPrerender) == kEnabledGroup;
 }
 
 }  // namespace prerender