InstantExtended: Add new_tab_url to TemplateURL.

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/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 44 matching lines @@
 
 // The staleness timeout can be set (in seconds) via this config.
 const char kStalePageTimeoutFlagName[] = "stale";
 const int kStalePageTimeoutDefault = 3 * 3600;  // 3 hours.
 const int kStalePageTimeoutDisabled = 0;
 
 const char kHideVerbatimFlagName[] = "hide_verbatim";
 const char kUseRemoteNTPOnStartupFlagName[] = "use_remote_ntp_on_startup";
 const char kShowNtpFlagName[] = "show_ntp";
 const char kRecentTabsOnNTPFlagName[] = "show_recent_tabs";
+const char kUseCacheableNTP[] = "use_cacheable_ntp";
 
 // Constants for the field trial name and group prefix.
 const char kInstantExtendedFieldTrialName[] = "InstantExtended";
 const char kGroupNumberPrefix[] = "Group";
 
 // If the field trial's group name ends with this string its configuration will
 // be ignored and Instant Extended will not be enabled by default.
 const char kDisablingSuffix[] = "DISABLED";
 
 // Remember if we reported metrics about opt-in/out state.
@@ skipping 38 matching lines @@
 GURL TemplateURLRefToGURL(const TemplateURLRef& ref,
                           int start_margin,
                           bool append_extra_query_params) {
   TemplateURLRef::SearchTermsArgs search_terms_args =
       TemplateURLRef::SearchTermsArgs(string16());
   search_terms_args.omnibox_start_margin = start_margin;
   search_terms_args.append_extra_query_params = append_extra_query_params;
   return GURL(ref.ReplaceSearchTerms(search_terms_args));
 }
 
+GURL GetNewTabPageURL(Profile* profile) {
+  if (!ShouldUseCacheableNTP())
+    return GURL();
+
+  if (!profile)
+    return GURL();
+
+  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
+  if (!template_url)
+    return GURL();
+
+  return TemplateURLRefToGURL(template_url->new_tab_url_ref(),
+                              kDisableStartMargin, false);
+}
+
 bool MatchesOrigin(const GURL& my_url, const GURL& other_url) {
   return my_url.host() == other_url.host() &&
          my_url.port() == other_url.port() &&
          (my_url.scheme() == other_url.scheme() ||
           (my_url.SchemeIs(chrome::kHttpsScheme) &&
            other_url.SchemeIs(chrome::kHttpScheme)));
 }
 
 bool MatchesAnySearchURL(const GURL& url, TemplateURL* template_url) {
   GURL search_url =
@@ skipping 51 matching lines @@
 //     expected to be the TemplateURL* for the default search provider.
 // (2) Either it has a secure scheme, or else the user has manually specified a
 //     --google-base-url and it uses that base URL.  (This allows testers to use
 //     --google-base-url to point at non-HTTPS servers, which eases testing.)
 bool IsSuitableURLForInstant(const GURL& url, const TemplateURL* template_url) {
   return template_url->HasSearchTermsReplacementKey(url) &&
       (url.SchemeIsSecure() ||
        google_util::StartsWithCommandLineGoogleBaseURL(url));
 }
 
-// Returns true if |url| matches --instant-new-tab-url.
-bool IsCommandLineInstantNTPURL(const GURL& url) {
-  const GURL ntp_url(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      switches::kInstantNewTabURL));
-  return ntp_url.is_valid() && MatchesOriginAndPath(ntp_url, url);
-}
-
 // Returns true if |url| can be used as an Instant URL for |profile|.
 bool IsInstantURL(const GURL& url, Profile* profile) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   if (!url.is_valid())
     return false;
 
-  if (IsCommandLineInstantNTPURL(url))
+  const GURL new_tab_url(GetNewTabPageURL(profile));
+  if (new_tab_url.is_valid() && MatchesOriginAndPath(url, new_tab_url))
     return true;
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return false;
 
   if (!IsSuitableURLForInstant(url, template_url))
     return false;
 
   const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
@@ skipping 161 matching lines @@
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   if (!IsInstantExtendedAPIEnabled() ||
       !IsRenderedInInstantProcess(contents, profile))
     return false;
 
   if (IsInstantURL(entry->GetVirtualURL(), profile) ||
       entry->GetVirtualURL() == GetLocalInstantURL(profile))
     return GetSearchTermsImpl(contents, entry).empty();
 
+  GURL new_tab_url(GetNewTabPageURL(profile));
   return entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL) &&
-      IsCommandLineInstantNTPURL(entry->GetURL());
+      new_tab_url.is_valid() &&
+      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) {
   if (!IsInstantExtendedAPIEnabled() || !IsSuggestPrefEnabled(profile))
     return GURL();
@@ skipping 48 matching lines @@
 bool ShouldHideTopVerbatimMatch() {
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(
       base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
       &flags, NULL)) {
     return GetBoolValueForFlagWithDefault(kHideVerbatimFlagName, false, flags);
   }
   return false;
 }
 
+bool ShouldUseCacheableNTP() {
+  FieldTrialFlags flags;
+  if (GetFieldTrialInfo(
+          base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
+          &flags, NULL)) {
+    return GetBoolValueForFlagWithDefault(kUseCacheableNTP, false, flags);
+  }
+  return false;
+}
+
 bool ShouldShowInstantNTP() {
-  // If the instant-new-tab-url flag is set, we'll always just load the NTP
-  // directly instead of preloading contents using InstantNTP.
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kInstantNewTabURL))
+  // If using the cacheable NTP, load the NTP directly instead of preloading its
+  // contents using InstantNTP.
+  if (ShouldUseCacheableNTP())
     return false;
 
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(
           base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
           &flags, NULL)) {
     return GetBoolValueForFlagWithDefault(kShowNtpFlagName, true, flags);
   }
   return true;
 }
@@ skipping 87 matching lines @@
 
 bool HandleNewTabURLRewrite(GURL* url,
                             content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   if (!url->SchemeIs(chrome::kChromeUIScheme) ||
       url->host() != chrome::kChromeUINewTabHost)
     return false;
 
-  const GURL ntp_url(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      switches::kInstantNewTabURL));
-  if (!ntp_url.is_valid())
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  GURL new_tab_url(GetNewTabPageURL(profile));
+  if (!new_tab_url.is_valid())
     return false;
 
-  *url = ntp_url;
+  *url = new_tab_url;
   return true;
 }
 
 bool HandleNewTabURLReverseRewrite(GURL* url,
                                    content::BrowserContext* browser_context) {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
-  const GURL ntp_url(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-      switches::kInstantNewTabURL));
-  if (!MatchesOriginAndPath(ntp_url, *url))
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  GURL new_tab_url(GetNewTabPageURL(profile));
+  if (!new_tab_url.is_valid() || !MatchesOriginAndPath(new_tab_url, *url))
     return false;
 
   *url = GURL(chrome::kChromeUINewTabURL);
   return true;
 }
 
 void SetInstantSupportStateInNavigationEntry(InstantSupportState state,
                                              content::NavigationEntry* entry) {
   if (!entry)
     return;
@@ skipping 92 matching lines @@
                                     bool default_value,
                                     const FieldTrialFlags& flags) {
   return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags);
 }
 
 void ResetInstantExtendedOptInStateGateForTest() {
   instant_extended_opt_in_state_gate = false;
 }
 
 }  // namespace chrome