Stop depending on InstantService from BaseSearchProvider

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 152 matching lines @@
     TemplateURLService* template_url_service =
         TemplateURLServiceFactory::GetForProfile(profile);
     if (template_url_service)
       return template_url_service->GetDefaultSearchProvider();
   }
   return NULL;
 }
 
 GURL TemplateURLRefToGURL(const TemplateURLRef& ref,
                           const SearchTermsData& search_terms_data,
-                          int start_margin,
                           bool append_extra_query_params,
                           bool force_instant_results) {
   TemplateURLRef::SearchTermsArgs search_terms_args =
       TemplateURLRef::SearchTermsArgs(base::string16());
-  search_terms_args.omnibox_start_margin = start_margin;
   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) {
-  GURL search_url =
-      TemplateURLRefToGURL(template_url->url_ref(), search_terms_data,
-                           kDisableStartMargin, false, false);
+  GURL search_url = TemplateURLRefToGURL(template_url->url_ref(),
+                                         search_terms_data, false, false);
   if (search_url.is_valid() &&
       search::MatchesOriginAndPath(url, search_url))
     return true;
 
   // "URLCount() - 1" because we already tested url_ref above.
   for (size_t i = 0; i < template_url->URLCount() - 1; ++i) {
     TemplateURLRef ref(template_url, i);
-    search_url = TemplateURLRefToGURL(ref, search_terms_data,
-                                      kDisableStartMargin, false, false);
+    search_url = TemplateURLRefToGURL(ref, search_terms_data, false, false);
     if (search_url.is_valid() &&
         search::MatchesOriginAndPath(url, search_url))
       return true;
   }
 
   return false;
 }
 
 
 
@@ skipping 22 matching lines @@
   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, kDisableStartMargin, false, false);
+      instant_url_ref, search_terms_data, false, false);
   if (!instant_url.is_valid())
     return false;
 
   if (search::MatchesOriginAndPath(url, instant_url))
     return true;
 
   return IsQueryExtractionEnabled() &&
       MatchesAnySearchURL(url, template_url, search_terms_data);
 }
 
@@ skipping 62 matching lines @@
       : url(url), state(state) {}
 
   static NewTabURLDetails ForProfile(Profile* profile) {
     const GURL local_url(chrome::kChromeSearchLocalNtpUrl);
     TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
     if (!profile || !template_url)
       return NewTabURLDetails(local_url, NEW_TAB_URL_BAD);
 
     GURL search_provider_url = TemplateURLRefToGURL(
         template_url->new_tab_url_ref(), UIThreadSearchTermsData(profile),
-        kDisableStartMargin, false, false);
+        false, false);
     NewTabURLState state = IsValidNewTabURL(profile, search_provider_url);
     switch (state) {
       case NEW_TAB_URL_VALID:
         // We can use the search provider's page.
         return NewTabURLDetails(search_provider_url, state);
       case NEW_TAB_URL_INCOGNITO:
         // Incognito has its own New Tab.
         return NewTabURLDetails(GURL(), state);
       default:
         // Use the local New Tab otherwise.
@@ skipping 185 matching lines @@
   GURL new_tab_url(GetNewTabPageURL(profile));
   return new_tab_url.is_valid() &&
       search::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,
-                   bool force_instant_results) {
+GURL GetInstantURL(Profile* profile, bool force_instant_results) {
   if (!IsInstantExtendedAPIEnabled() || !IsSuggestPrefEnabled(profile))
     return GURL();
 
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return GURL();
 
   GURL instant_url = TemplateURLRefToGURL(
       template_url->instant_url_ref(), UIThreadSearchTermsData(profile),
-      start_margin, true, force_instant_results);
+      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()).
   if (!instant_url.SchemeIsSecure() &&
       !google_util::StartsWithCommandLineGoogleBaseURL(instant_url)) {
     GURL::Replacements replacements;
@@ skipping 19 matching lines @@
 
 // Returns URLs associated with the default search engine for |profile|.
 std::vector<GURL> GetSearchURLs(Profile* profile) {
   std::vector<GURL> result;
   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
   if (!template_url)
     return result;
   for (size_t i = 0; i < template_url->URLCount(); ++i) {
     TemplateURLRef ref(template_url, i);
     result.push_back(TemplateURLRefToGURL(ref, UIThreadSearchTermsData(profile),
-                                          kDisableStartMargin, false, false));
+                                          false, false));
   }
   return result;
 }
 
 GURL GetNewTabPageURL(Profile* profile) {
   return NewTabURLDetails::ForProfile(profile).url;
 }
 
 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
-  return ShouldPrefetchSearchResults() ?
-      GetInstantURL(profile, kDisableStartMargin, true) : GURL();
+  return ShouldPrefetchSearchResults() ? GetInstantURL(profile, true) : GURL();
 }
 
 bool ShouldPrefetchSearchResults() {
   if (!IsInstantExtendedAPIEnabled())
     return false;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kPrefetchSearchResults)) {
     return true;
   }
@@ skipping 256 matching lines @@
   return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags);
 }
 
 bool ShouldUseAltInstantURL() {
   FieldTrialFlags flags;
   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
       kUseAltInstantURL, false, flags);
 }
 
 }  // namespace chrome