Remove call to IsInstantExtendedAPIGoogleSearchUrl from ToolbarModel.

chrome/browser/search_engines/template_url.cc

 // Copyright (c) 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_engines/template_url.h"
 
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
@@ skipping 42 matching lines @@
 
 // Like google:baseURL, but for the Search Suggest capability.
 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL";
 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}";
 const char kGoogleCursorPositionParameter[] = "google:cursorPosition";
 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter";
 const char kGoogleInstantExtendedEnabledParameter[] =
     "google:instantExtendedEnabledParameter";
 const char kGoogleInstantExtendedEnabledKey[] =
     "google:instantExtendedEnabledKey";
+const char kGoogleInstantExtendedEnabledKeyFull[] =
+    "{google:instantExtendedEnabledKey}";
 const char kGoogleOriginalQueryForSuggestionParameter[] =
     "google:originalQueryForSuggestion";
 const char kGoogleRLZParameter[] = "google:RLZ";
 const char kGoogleSearchClient[] = "google:searchClient";
 const char kGoogleSearchFieldtrialParameter[] =
     "google:searchFieldtrialParameter";
 const char kGoogleSourceIdParameter[] = "google:sourceId";
 const char kGoogleSuggestAPIKeyParameter[] = "google:suggestAPIKeyParameter";
 
 // Same as kSearchTermsParameter, with no escaping.
@@ skipping 667 matching lines @@
 
 TemplateURL::TemplateURL(Profile* profile, const TemplateURLData& data)
     : profile_(profile),
       data_(data),
       url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this), TemplateURLRef::SEARCH),
       suggestions_url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                            TemplateURLRef::SUGGEST),
       instant_url_ref_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                        TemplateURLRef::INSTANT) {
   SetPrepopulateId(data_.prepopulate_id);
+
+  if (data_.search_terms_replacement_key ==
+      kGoogleInstantExtendedEnabledKeyFull) {
+    data_.search_terms_replacement_key = google_util::kInstantExtendedAPIParam;
+  }
 }
 
 TemplateURL::~TemplateURL() {
 }
 
 // static
 GURL TemplateURL::GenerateFaviconURL(const GURL& url) {
   DCHECK(url.is_valid());
   GURL::Replacements rep;
 
@@ skipping 54 matching lines @@
   return data_.alternate_urls.size() + 1;
 }
 
 const std::string& TemplateURL::GetURL(size_t index) const {
   DCHECK_LT(index, URLCount());
 
   return (index < data_.alternate_urls.size()) ?
       data_.alternate_urls[index] : url();
 }
 
-bool TemplateURL::ExtractSearchTermsFromURL(
-    const GURL& url, string16* search_terms) {
+bool TemplateURL::ExtractSearchTermsFromURL(const GURL& url,
+                                            string16* search_terms) {
   DCHECK(search_terms);
   search_terms->clear();
 
   // Then try to match with every pattern.
   for (size_t i = 0; i < URLCount(); ++i) {
     TemplateURLRef ref(this, i);
     if (ref.ExtractSearchTermsFromURL(url, search_terms)) {
       // If ExtractSearchTermsFromURL() returns true and |search_terms| is empty
       // it means the pattern matched but no search terms were present. In this
       // case we fail immediately without looking for matches in subsequent
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }
 
+bool TemplateURL::HasSearchTermsReplacementKey(const GURL& url) const {
+  // Look for the key both in the query and the ref.
+  std::string params[] = {url.query(), url.ref()};
+
+  for (int i = 0; i < 2; ++i) {
+    url_parse::Component query, key, value;
+    query.len = static_cast<int>(params[i].size());
+    while (url_parse::ExtractQueryKeyValue(params[i].c_str(), &query, &key,
+                                           &value)) {
+      if (key.is_nonempty() &&
+          params[i].substr(key.begin, key.len) ==
+              search_terms_replacement_key()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 void TemplateURL::CopyFrom(const TemplateURL& other) {
   if (this == &other)
     return;
 
   profile_ = other.profile_;
   data_ = other.data_;
   url_ref_.InvalidateCachedValues();
   suggestions_url_ref_.InvalidateCachedValues();
   instant_url_ref_.InvalidateCachedValues();
   SetPrepopulateId(other.data_.prepopulate_id);
@@ skipping 13 matching lines @@
 }
 
 void TemplateURL::ResetKeywordIfNecessary(bool force) {
   if (IsGoogleSearchURLWithReplaceableKeyword() || force) {
     DCHECK(!IsExtensionKeyword());
     GURL url(TemplateURLService::GenerateSearchURL(this));
     if (url.is_valid())
       data_.SetKeyword(TemplateURLService::GenerateKeyword(url));
   }
 }