Cleanup in components/search and chrome/browser/search

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 102 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));
 }
 
+// |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 IsSuitableURLForInstant(const GURL& url, const TemplateURL* template_url) {
+  return template_url->HasSearchTermsReplacementKey(url) &&
+         (url.SchemeIsCryptographic() ||
+          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() && MatchesOriginAndPath(url, new_tab_url))
@@ skipping 121 matching lines @@
   }
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   base::string16 search_terms;
   if (template_url)
     template_url->ExtractSearchTermsFromURL(
         url, UIThreadSearchTermsData(profile), &search_terms);
   return search_terms;
 }
 
-bool IsQueryExtractionAllowedForURL(Profile* profile, const GURL& url) {
-  TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
-  return template_url && IsSuitableURLForInstant(url, template_url);
-}
-
 bool ShouldAssignURLToInstantRenderer(const GURL& url, Profile* profile) {
   return url.is_valid() &&
          profile &&
          IsInstantExtendedAPIEnabled() &&
          (url.SchemeIs(chrome::kChromeSearchScheme) ||
           IsInstantURL(url, profile));
 }
 
 bool IsRenderedInInstantProcess(const content::WebContents* contents,
                                 Profile* profile) {
@@ skipping 106 matching lines @@
                                           false, false));
   }
   return result;
 }
 
 GURL GetNewTabPageURL(Profile* profile) {
   return NewTabURLDetails::ForProfile(profile).url;
 }
 
 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
-  return ShouldPrefetchSearchResults() ? GetInstantURL(profile, true) : GURL();
+  return GetInstantURL(profile, true);
 }
 
 GURL GetEffectiveURLForInstant(const GURL& url, Profile* profile) {
   CHECK(ShouldAssignURLToInstantRenderer(url, profile))
       << "Error granting Instant access.";
 
   if (url.SchemeIs(chrome::kChromeSearchScheme))
     return url;
 
   // Replace the scheme with "chrome-search:", and clear the port, since
@@ skipping 49 matching lines @@
 
   if (IsInstantNTPURL(*url, profile)) {
     *url = GURL(chrome::kChromeUINewTabURL);
     return true;
   }
 
   return false;
 }
 
 }  // namespace search