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 452 matching lines @@
 bool TemplateURLRef::HasGoogleBaseURLs() const {
   ParseIfNecessary();
   for (size_t i = 0; i < replacements_.size(); ++i) {
     if ((replacements_[i].type == GOOGLE_BASE_URL) ||
         (replacements_[i].type == GOOGLE_BASE_SUGGEST_URL))
       return true;
   }
   return false;
 }
 
-bool TemplateURLRef::ExtractSearchTermsFromURL(const GURL& url,
-                                               string16* search_terms) const {
+bool TemplateURLRef::ExtractSearchTermsFromURL(
+    const GURL& url,
+    string16* search_terms,
+    bool needs_instant_extended) const {
   DCHECK(search_terms);
   search_terms->clear();
 
   ParseIfNecessary();
 
   // We need a search term in the template URL to extract something.
   if (search_term_key_.empty())
     return false;
 
   // TODO(beaudoin): Support patterns of the form http://foo/{searchTerms}/
   // See crbug.com/153798
 
   // Fill-in the replacements. We don't care about search terms in the pattern,
   // so we use the empty string.
   GURL pattern(ReplaceSearchTerms(SearchTermsArgs(string16())));
   // Host, path and port must match.
   if (url.port() != pattern.port() ||
       url.host() != host_ ||
       url.path() != path_) {
     return false;
   }
 
   // Parameter must be present either in the query or the ref.
   const std::string& params(
       (search_term_key_location_ == url_parse::Parsed::QUERY) ?
           url.query() : url.ref());
 
   url_parse::Component query, key, value;
   query.len = static_cast<int>(params.size());
+  bool search_terms_found = false, replacement_key_found = false;
   while (url_parse::ExtractQueryKeyValue(params.c_str(), &query, &key,
                                          &value)) {
     if (key.is_nonempty()) {
-      if (params.substr(key.begin, key.len) == search_term_key_) {
+      base::StringPiece key_string(params.begin() + key.begin,

[Peter Kasting, 2012/12/18 02:09:22]

Does using a StringPiece here actually buy much?  Normally I'd just use a
string.

[beaudoin, 2012/12/20 04:40:56]

Thought it may have been worth not copying characters around the heap inside a
loop, especially since the API is so similar to a string. If you feel strongly I
can switch back to a string.

[Peter Kasting, 2012/12/20 19:40:16]

I don't really care too much, the string version just seemed a little less
verbose.  Note that we already use substr() (and thus generate a string) below
in the StringToInt() call, so just doing that here too would be consistent.

[beaudoin, 2013/01/08 16:55:39]

Done.

+                                   params.begin() + key.begin + key.len);
+      if (key_string == search_term_key_) {
         // Extract the search term.
         *search_terms = net::UnescapeAndDecodeUTF8URLComponent(
             params.substr(value.begin, value.len),
             net::UnescapeRule::SPACES |
                 net::UnescapeRule::URL_SPECIAL_CHARS |
                 net::UnescapeRule::REPLACE_PLUS_WITH_SPACE,
             NULL);
+        search_terms_found = true;
+      }
+      if (key_string == owner_->search_terms_replacement_key()) {
+        int int_value = 0;
+        if (value.is_nonempty())
+          base::StringToInt(params.substr(value.begin, value.len), &int_value);
+        if (int_value != 0)
+          replacement_key_found = true;
+      }
+      if (search_terms_found &&
+          (replacement_key_found || !needs_instant_extended)) {
         return true;
       }
     }
   }
+  search_terms->clear();
   return false;
 }
 
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
   host_.clear();
   path_.clear();
   search_term_key_.clear();
   replacements_.clear();
 }
@@ skipping 291 matching lines @@
 }
 
 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) {
+    const GURL& url, string16* search_terms, bool needs_instant_extended) {

[Peter Kasting, 2012/12/18 02:09:22]

Nit: One arg per line (and 1st arg can move up a line)

[beaudoin, 2012/12/20 04:40:56]

Done.

   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 (ref.ExtractSearchTermsFromURL(url, search_terms,
+                                      needs_instant_extended)) {
       // 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();
     }
@@ skipping 27 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));
   }
 }