Revert 244407 "InstantExtended: remove dead code related to the ..."

trunk/src/chrome/browser/search/search.cc

 // Copyright 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/search/search.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
+#include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search_engines/template_url_service.h"
@@ skipping 31 matching lines @@
 // Field trial groups should be named things like "Group7 espv:2 instant:1".
 // The first token is always GroupN for some integer N, followed by a
 // space-delimited list of key:value pairs which correspond to these flags:
 const char kEmbeddedPageVersionFlagName[] = "espv";
 #if defined(OS_IOS) || defined(OS_ANDROID)
 const uint64 kEmbeddedPageVersionDefault = 1;
 #else
 const uint64 kEmbeddedPageVersionDefault = 2;
 #endif
 
+// The staleness timeout can be set (in seconds) via this config.
+const char kStalePageTimeoutFlagName[] = "stale";
+const int kStalePageTimeoutDefault = 3 * 3600;  // 3 hours.
+
 const char kHideVerbatimFlagName[] = "hide_verbatim";
+const char kShowNtpFlagName[] = "show_ntp";
+const char kUseCacheableNTP[] = "use_cacheable_ntp";
 const char kPrefetchSearchResultsFlagName[] = "prefetch_results";
 const char kPrefetchSearchResultsOnSRP[] = "prefetch_results_srp";
 const char kDisplaySearchButtonFlagName[] = "display_search_button";
 const char kOriginChipFlagName[] = "origin_chip";
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
 const char kEnableQueryExtractionFlagName[] = "query_extraction";
 #endif
 
 // Constants for the field trial name and group prefix.
 // Note in M30 and below this field trial was named "InstantExtended" and in
@@ skipping 309 matching lines @@
   if (!contents || !entry || !IsInstantExtendedAPIEnabled())
     return false;
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   if (!IsRenderedInInstantProcess(contents, profile))
     return false;
 
   if (entry->GetURL() == GetLocalInstantURL(profile))
     return true;
 
-  GURL new_tab_url(GetNewTabPageURL(profile));
-  return new_tab_url.is_valid() &&
-      search::MatchesOriginAndPath(entry->GetURL(), new_tab_url);
+  if (ShouldUseCacheableNTP()) {
+    GURL new_tab_url(GetNewTabPageURL(profile));
+    return new_tab_url.is_valid() &&
+        search::MatchesOriginAndPath(entry->GetURL(), new_tab_url);
+  }
+
+  return IsInstantURL(entry->GetVirtualURL(), profile) &&
+      GetSearchTermsImpl(contents, entry).empty();
 }
 
 bool IsSuggestPrefEnabled(Profile* profile) {
   return profile && !profile->IsOffTheRecord() && profile->GetPrefs() &&
          profile->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled);
 }
 
 GURL GetInstantURL(Profile* profile, int start_margin,
                    bool force_instant_results) {
   if (!IsInstantExtendedAPIEnabled() || !IsSuggestPrefEnabled(profile))
@@ skipping 35 matching lines @@
     return result;
   for (size_t i = 0; i < template_url->URLCount(); ++i) {
     TemplateURLRef ref(template_url, i);
     result.push_back(TemplateURLRefToGURL(ref, kDisableStartMargin, false,
                                           false));
   }
   return result;
 }
 
 GURL GetNewTabPageURL(Profile* profile) {
+  if (!ShouldUseCacheableNTP())
+    return GURL();
+
   if (!profile || profile->IsOffTheRecord())
     return GURL();
 
   if (!IsSuggestPrefEnabled(profile))
     return GURL(chrome::kChromeSearchLocalNtpUrl);
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return GURL(chrome::kChromeSearchLocalNtpUrl);
 
   GURL url(TemplateURLRefToGURL(template_url->new_tab_url_ref(),
                                 kDisableStartMargin, false, false));
   if (!url.is_valid() || !url.SchemeIsSecure())
     return GURL(chrome::kChromeSearchLocalNtpUrl);
 
   if (!IsURLAllowedForSupervisedUser(url, profile))
     return GURL(chrome::kChromeSearchLocalNtpUrl);
 
   return url;
 }
 
 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
   return ShouldPrefetchSearchResults() ?
       GetInstantURL(profile, kDisableStartMargin, true) : GURL();
 }
 
 bool ShouldPrefetchSearchResults() {
+  if (!ShouldUseCacheableNTP())
+    return false;
+
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kPrefetchSearchResultsFlagName, false, flags);
 }
 
 GURL GetLocalInstantURL(Profile* profile) {
   return GURL(chrome::kChromeSearchLocalNtpUrl);
 }
 
 bool ShouldHideTopVerbatimMatch() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kHideVerbatimFlagName, false, flags);
 }
 
+bool ShouldUseCacheableNTP() {
+  FieldTrialFlags flags;
+  return !GetFieldTrialInfo(&flags) || GetBoolValueForFlagWithDefault(
+      kUseCacheableNTP, true, flags);
+}
+
+bool ShouldShowInstantNTP() {
+  // If using the cacheable NTP, load the NTP directly instead of preloading its
+  // contents using InstantNTP.
+  if (ShouldUseCacheableNTP())
+    return false;
+
+  FieldTrialFlags flags;
+  return !GetFieldTrialInfo(&flags) ||
+      GetBoolValueForFlagWithDefault(kShowNtpFlagName, true, flags);
+}
+
 DisplaySearchButtonConditions GetDisplaySearchButtonConditions() {
   const CommandLine* cl = CommandLine::ForCurrentProcess();
   if (cl->HasSwitch(switches::kDisableSearchButtonInOmnibox)) {
     return DISPLAY_SEARCH_BUTTON_NEVER;
   } else if (cl->HasSwitch(switches::kEnableSearchButtonInOmniboxForStr)) {
     return DISPLAY_SEARCH_BUTTON_FOR_STR;
   } else if (cl->HasSwitch(switches::kEnableSearchButtonInOmniboxForStrOrIip)) {
     return DISPLAY_SEARCH_BUTTON_FOR_STR_OR_IIP;
   } else if (cl->HasSwitch(switches::kEnableSearchButtonInOmniboxAlways)) {
     return DISPLAY_SEARCH_BUTTON_ALWAYS;
@@ skipping 62 matching lines @@
         search::MatchesOriginAndPath(url, instant_url)) {
       replacements.SetHost(online_ntp_host.c_str(),
                            url_parse::Component(0, online_ntp_host.length()));
     }
   }
 
   effective_url = effective_url.ReplaceComponents(replacements);
   return effective_url;
 }
 
+int GetInstantLoaderStalenessTimeoutSec() {
+  int timeout_sec = kStalePageTimeoutDefault;
+  FieldTrialFlags flags;
+  if (GetFieldTrialInfo(&flags)) {
+    timeout_sec = GetUInt64ValueForFlagWithDefault(kStalePageTimeoutFlagName,
+                                                   kStalePageTimeoutDefault,
+                                                   flags);
+  }
+
+  // Require a minimum 5 minute timeout.
+  if (timeout_sec < 0 || (timeout_sec > 0 && timeout_sec < 300))
+    timeout_sec = kStalePageTimeoutDefault;
+
+  // Randomize by upto 15% either side.
+  timeout_sec = base::RandInt(timeout_sec * 0.85, timeout_sec * 1.15);
+
+  return timeout_sec;
+}
+
+bool IsPreloadedInstantExtendedNTP(const content::WebContents* contents) {
+  if (!IsInstantExtendedAPIEnabled())
+    return false;
+
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  if (!profile_manager)
+    return false;  // The profile manager can be NULL while testing.
+
+  const std::vector<Profile*>& profiles = profile_manager->GetLoadedProfiles();
+  for (size_t i = 0; i < profiles.size(); ++i) {
+    const InstantService* instant_service =
+        InstantServiceFactory::GetForProfile(profiles[i]);
+    if (instant_service && instant_service->GetNTPContents() == contents)
+      return true;
+  }
+  return false;
+}
+
 bool HandleNewTabURLRewrite(GURL* url,
                             content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   if (!url->SchemeIs(chrome::kChromeUIScheme) ||
       url->host() != chrome::kChromeUINewTabHost)
     return false;
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
@@ skipping 106 matching lines @@
 
 // Given a FieldTrialFlags object, returns the boolean value of the provided
 // flag.
 bool GetBoolValueForFlagWithDefault(const std::string& flag,
                                     bool default_value,
                                     const FieldTrialFlags& flags) {
   return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags);
 }
 
 }  // namespace chrome