InstantExtended: remove dead code related to the non-cacheable NTP.

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 kEnableOriginChipFlagName[] = "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 273 matching lines @@
   return url.is_valid() &&
          profile &&
          IsInstantExtendedAPIEnabled() &&
          (url.SchemeIs(chrome::kChromeSearchScheme) ||
           IsInstantURL(url, profile));
 }
 
 bool ShouldUseProcessPerSiteForInstantURL(const GURL& url, Profile* profile) {
   return ShouldAssignURLToInstantRenderer(url, profile) &&
       (url.host() == chrome::kChromeSearchLocalNtpHost ||
        url.host() == chrome::kChromeSearchOnlineNtpHost);

[Jered, 2014/01/10 16:29:41]

I think we can get rid of this constant now.

[samarth, 2014/01/10 20:50:21]

Actually this brings to mind a bug with the cacheable ntp.  See
crbug.com/333397.  Let's clean it up with that.

 }
 
 bool IsNTPURL(const GURL& url, Profile* profile) {
   if (!url.is_valid())
     return false;
 
   if (!IsInstantExtendedAPIEnabled())
     return url == GURL(chrome::kChromeUINewTabURL);
 
   return profile &&
@@ skipping 15 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;
 
-  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();
+  GURL new_tab_url(GetNewTabPageURL(profile));
+  return new_tab_url.is_valid() &&
+      search::MatchesOriginAndPath(entry->GetURL(), new_tab_url);
 }
 
 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 32 matching lines @@
   GURL effective_url(url);
 
   // Replace the scheme with "chrome-search:".
   url_canon::Replacements<char> replacements;
   std::string search_scheme(chrome::kChromeSearchScheme);
   replacements.SetScheme(search_scheme.data(),
                          url_parse::Component(0, search_scheme.length()));
 
   // If the URL corresponds to an online NTP, replace the host with
   // "online-ntp".
   std::string online_ntp_host(chrome::kChromeSearchOnlineNtpHost);

[Jered, 2014/01/10 16:29:41]

Here, too.

[samarth, 2014/01/10 20:50:21]

Same.

   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (template_url) {
     const GURL instant_url = TemplateURLRefToGURL(
         template_url->instant_url_ref(), kDisableStartMargin, false, false);
     if (instant_url.is_valid() &&
         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