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) {
+  FieldTrialFlags flags;
+  if (!GetFieldTrialInfo(
+          base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
+          &flags, NULL))
+    return GURL();
+
+  if (!GetBoolValueForFlagWithDefault(kUseCacheableNTP, false, flags))
+    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 162 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();
 
   return entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL) &&
-      IsCommandLineInstantNTPURL(entry->GetURL());
+      MatchesOriginAndPath(entry->GetURL(), GetNewTabPageURL(profile));

[samarth, 2013/08/13 23:47:59]

In the previous check you check that GetNewTabPageURL is valid but not down
here.  If it doesn't matter, just remove that check from above.  Else, add it
here.

[Jered, 2013/08/14 15:41:49]

Done.

 }
 
 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 49 matching lines @@
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(
       base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
       &flags, NULL)) {
     return GetBoolValueForFlagWithDefault(kHideVerbatimFlagName, 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))
-    return false;
-
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(
           base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
           &flags, NULL)) {
+    // If the use_cacheable_ntp field trial flag is set, load the NTP directly

[samarth, 2013/08/13 23:47:59]

Please make this into a helper (ShouldUseCacheableNTP).  Otherwise, it would be
easy to try and change the default and get it wrong.

[Jered, 2013/08/14 15:41:49]

Done.

+    // instead of preloading contents using InstantNTP.
+    if (GetBoolValueForFlagWithDefault(kUseCacheableNTP, false, flags))
+      return false;
     return GetBoolValueForFlagWithDefault(kShowNtpFlagName, true, flags);
   }
   return true;
 }
 
 bool ShouldShowRecentTabsOnNTP() {
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(
           base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
           &flags, NULL)) {
@@ skipping 81 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())
+  GURL new_tab_url(GetNewTabPageURL(

[samarth, 2013/08/13 23:47:59]

nit: fits on one line?

[Jered, 2013/08/14 15:41:49]

Split out profile.

+      Profile::FromBrowserContext(browser_context)));
+  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))
+  GURL new_tab_url(GetNewTabPageURL(
+      Profile::FromBrowserContext(browser_context)));
+  if (!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