Integrate the LocalPredictor with the Prerender Service.

chrome/browser/prerender/prerender_field_trial.cc

Index: chrome/browser/prerender/prerender_field_trial.cc
===================================================================
--- chrome/browser/prerender/prerender_field_trial.cc	(revision 220426)
+++ chrome/browser/prerender/prerender_field_trial.cc	(working copy)
@@ -15,6 +15,8 @@
 #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"
 
@@ -37,9 +39,16 @@
 
 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";
@@ -47,8 +56,16 @@
 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();
@@ -291,7 +308,16 @@
   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
@@ -302,12 +328,27 @@
   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;
 }
@@ -321,6 +362,42 @@
       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);
@@ -365,6 +442,10 @@
   return GetLocalPredictorSpecValue(kSkipWhitelist) == kEnabledGroup;
 }
 
+bool SkipLocalPredictorServiceWhitelist() {
+  return GetLocalPredictorSpecValue(kSkipServiceWhitelist) == kEnabledGroup;
+}
+
 bool SkipLocalPredictorLoggedIn() {
   return GetLocalPredictorSpecValue(kSkipLoggedIn) == kEnabledGroup;
 }