Remove search::IsQueryExtractionEnabled

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 <stddef.h>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
@@ skipping 136 matching lines @@
                           const SearchTermsData& search_terms_data,
                           bool append_extra_query_params,
                           bool force_instant_results) {
   TemplateURLRef::SearchTermsArgs search_terms_args =
       TemplateURLRef::SearchTermsArgs(base::string16());
   search_terms_args.append_extra_query_params = append_extra_query_params;
   search_terms_args.force_instant_results = force_instant_results;
   return GURL(ref.ReplaceSearchTerms(search_terms_args, search_terms_data));
 }
 
-bool MatchesAnySearchURL(const GURL& url,
-                         TemplateURL* template_url,
-                         const SearchTermsData& search_terms_data) {
-  for (const TemplateURLRef& ref : template_url->url_refs()) {
-    GURL search_url =
-        TemplateURLRefToGURL(ref, search_terms_data, false, false);
-    if (search_url.is_valid() && MatchesOriginAndPath(url, search_url))
-      return true;
-  }
-  return false;
-}
-
 // 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() && 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();
   UIThreadSearchTermsData search_terms_data(profile);
   const GURL instant_url = TemplateURLRefToGURL(
       instant_url_ref, search_terms_data, false, false);
   if (!instant_url.is_valid())
     return false;
 
-  if (MatchesOriginAndPath(url, instant_url))
-    return true;
-
-  return IsQueryExtractionEnabled() &&
-      MatchesAnySearchURL(url, template_url, search_terms_data);
+  return MatchesOriginAndPath(url, instant_url);
 }
 
 base::string16 GetSearchTermsImpl(const content::WebContents* contents,
                                   const content::NavigationEntry* entry) {
-  if (!contents || !IsQueryExtractionEnabled())
-    return base::string16();
-
-  // For security reasons, don't extract search terms if the page is not being
-  // rendered in the privileged Instant renderer process. This is to protect
-  // against a malicious page somehow scripting the search results page and
-  // faking search terms in the URL. Random pages can't get into the Instant
-  // renderer and scripting doesn't work cross-process, so if the page is in
-  // the Instant process, we know it isn't being exploited.
-  Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-  if (IsInstantExtendedAPIEnabled() &&
-      !IsRenderedInInstantProcess(contents, profile) &&
-      ((entry == contents->GetController().GetLastCommittedEntry()) ||
-       !ShouldAssignURLToInstantRenderer(entry->GetURL(), profile)))
-    return base::string16();
-
-  // 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 ExtractSearchTermsFromURL(profile, entry->GetVirtualURL());
+  // TODO(treib): Remove this and update callers accordingly. crbug.com/627747
+  return base::string16();
 }
 
 bool IsURLAllowedForSupervisedUser(const GURL& url, Profile* profile) {
 #if defined(ENABLE_SUPERVISED_USERS)
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile);
   SupervisedUserURLFilter* url_filter =
       supervised_user_service->GetURLFilterForUIThread();
   if (url_filter->GetFilteringBehaviorForURL(url) ==
           SupervisedUserURLFilter::BLOCK) {
@@ skipping 364 matching lines @@
       kUseAltInstantURL, false, flags);
 }
 
 bool ShouldUseSearchPathForInstant() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kUseSearchPathForInstant, false, flags);
 }
 
 }  // namespace search