Create a new helper function to extract search terms from the URL irrespective of the availablility

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 185 matching lines @@
     return false;
 
   const InstantService* instant_service =
       InstantServiceFactory::GetForProfile(profile);
   if (!instant_service)
     return false;
 
   return instant_service->IsInstantProcess(process_host->GetID());
 }
 
-// Returns true if |url| passes some basic checks that must succeed for it to be
-// usable as an instant URL:
-// (1) It contains the search terms replacement key of |template_url|, which is
-//     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) {
+// |url| should either have a secure scheme or have a non-HTTPS base URL that
+// the user specified using --google-base-url. (This allows testers to use
+// --google-base-url to point at non-HTTPS servers, which eases testing.)
+bool IsSuitableURLForInstantImpl(const GURL& url,

[Jered, 2014/02/11 23:33:28]

nit: Either drop the Impl or rename this to match the other function.

[kmadhusu, 2014/02/12 00:24:57]

Dropped the Impl.

+                                 const TemplateURL* template_url) {
   return template_url->HasSearchTermsReplacementKey(url) &&
       (url.SchemeIsSecure() ||
        google_util::StartsWithCommandLineGoogleBaseURL(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;
 
   const GURL new_tab_url(GetNewTabPageURL(profile));
   if (new_tab_url.is_valid() &&
       search::MatchesOriginAndPath(url, new_tab_url))
     return true;
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return false;
 
-  if (!IsSuitableURLForInstant(url, template_url))
+  if (!IsSuitableURLForInstantImpl(url, template_url))
     return false;
 
   const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
   const GURL instant_url =
       TemplateURLRefToGURL(instant_url_ref, kDisableStartMargin, false, false);
   if (!instant_url.is_valid())
     return false;
 
   if (search::MatchesOriginAndPath(url, instant_url))
     return true;
@@ skipping 19 matching lines @@
   if (!IsRenderedInInstantProcess(contents, profile) &&
       ((entry == contents->GetController().GetLastCommittedEntry()) ||
        !ShouldAssignURLToInstantRenderer(entry->GetURL(), profile)))
     return base::string16();
 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
   // Check to see if search terms have already been extracted.
   base::string16 search_terms = GetSearchTermsFromNavigationEntry(entry);
   if (!search_terms.empty())
     return search_terms;
 
+  if (!IsQueryExtractionAllowedForURL(profile, entry->GetVirtualURL()))
+    return base::string16();
+
   // Otherwise, extract from the URL.
-  return GetSearchTermsFromURL(profile, entry->GetVirtualURL());
+  return ExtractSearchTermsFromURL(profile, entry->GetVirtualURL());
 }
 
 bool IsURLAllowedForSupervisedUser(const GURL& url, Profile* profile) {
 #if defined(ENABLE_MANAGED_USERS)
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile);
   ManagedModeURLFilter* url_filter =
       managed_user_service->GetURLFilterForUIThread();
   if (url_filter->GetFilteringBehaviorForURL(url) ==
           ManagedModeURLFilter::BLOCK) {
@@ skipping 86 matching lines @@
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kEnableQueryExtraction))
     return true;
 
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kEnableQueryExtractionFlagName, false, flags);
 #endif  // defined(OS_IOS) || defined(OS_ANDROID)
 }
 
-base::string16 GetSearchTermsFromURL(Profile* profile, const GURL& url) {
+base::string16 ExtractSearchTermsFromURL(Profile* profile, const GURL& url) {
   if (url.is_valid() && url == GetSearchResultPrefetchBaseURL(profile)) {
     // InstantSearchPrerenderer has the search query for the Instant search base
     // page.
     InstantSearchPrerenderer* prerenderer =
         InstantSearchPrerenderer::GetForProfile(profile);
     DCHECK(prerenderer);
     return prerenderer->get_last_query();
   }
 
+  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   base::string16 search_terms;
-  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
-  if (template_url && IsSuitableURLForInstant(url, template_url))
+  if (template_url)
     template_url->ExtractSearchTermsFromURL(url, &search_terms);
   return search_terms;
 }
 
+bool IsQueryExtractionAllowedForURL(Profile* profile, const GURL& url) {
+  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
+  return template_url && IsSuitableURLForInstantImpl(url, template_url);
+}
+
 base::string16 GetSearchTermsFromNavigationEntry(
     const content::NavigationEntry* entry) {
   base::string16 search_terms;
   if (entry)
     entry->GetExtraData(sessions::kSearchTermsKey, &search_terms);
   return search_terms;
 }
 
 base::string16 GetSearchTerms(const content::WebContents* contents) {
   if (!contents)
@@ skipping 29 matching lines @@
        url.host() == chrome::kChromeSearchOnlineNtpHost);
 }
 
 bool IsNTPURL(const GURL& url, Profile* profile) {
   if (!url.is_valid())
     return false;
 
   if (!IsInstantExtendedAPIEnabled())
     return url == GURL(chrome::kChromeUINewTabURL);
 
+  const base::string16 search_terms = ExtractSearchTermsFromURL(profile, url);
   return profile &&
-      ((IsInstantURL(url, profile) &&
-        GetSearchTermsFromURL(profile, url).empty()) ||
+      ((IsInstantURL(url, profile) && search_terms.empty()) ||
        url == GURL(chrome::kChromeSearchLocalNtpUrl));
 }
 
 bool IsInstantNTP(const content::WebContents* contents) {
   if (!contents)
     return false;
 
   return NavEntryIsInstantNTP(contents,
                               contents->GetController().GetVisibleEntry());
 }
@@ skipping 31 matching lines @@
 
   GURL instant_url =
       TemplateURLRefToGURL(template_url->instant_url_ref(), start_margin, true,
                            force_instant_results);
   if (!instant_url.is_valid() ||
       !template_url->HasSearchTermsReplacementKey(instant_url))
     return GURL();
 
   // Extended mode requires HTTPS.  Force it unless the base URL was overridden
   // on the command line, in which case we allow HTTP (see comments on
-  // IsSuitableURLForInstant()).
+  // IsSuitableURLForInstantImpl()).
   if (!instant_url.SchemeIsSecure() &&
       !google_util::StartsWithCommandLineGoogleBaseURL(instant_url)) {
     GURL::Replacements replacements;
     const std::string secure_scheme(content::kHttpsScheme);
     replacements.SetSchemeStr(secure_scheme);
     instant_url = instant_url.ReplaceComponents(replacements);
   }
 
   if (!IsURLAllowedForSupervisedUser(instant_url, profile))
     return GURL();
@@ skipping 293 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