Introduces a search term extraction mechanism working for arbitrary search providers.

chrome/browser/search_engines/template_url.cc

Index: chrome/browser/search_engines/template_url.cc
diff --git a/chrome/browser/search_engines/template_url.cc b/chrome/browser/search_engines/template_url.cc
index 1612f5a408da560bf1d264b4a67941daae9efa9f..7e617e43f9a882e38676e807843418bbdd744dde 100644
--- a/chrome/browser/search_engines/template_url.cc
+++ b/chrome/browser/search_engines/template_url.cc
@@ -107,6 +107,28 @@ bool TryEncoding(const string16& terms,
   return true;
 }
 
+// Extract query key and host given a list of parameters coming from the URL
+// query or ref.
+std::string FindSearchTermsKey(const std::string& params) {
+  if (params.empty())
+    return std::string();
+  url_parse::Component query, key, value;
+  query.len = static_cast<int>(params.size());
+  while (url_parse::ExtractQueryKeyValue(params.c_str(), &query, &key,
+                                         &value)) {
+    if (key.is_nonempty() && value.is_nonempty()) {
+      std::string value_string = params.substr(value.begin, value.len);
+      if (value_string.find(kSearchTermsParameterFull, 0) !=
+          std::string::npos ||
+          value_string.find(kGoogleUnescapedSearchTermsParameterFull, 0) !=
+          std::string::npos) {
+        return params.substr(key.begin, key.len);
+      }
+    }
+  }
+  return std::string();
+}
+
 }  // namespace
 
 
@@ -123,11 +145,27 @@ TemplateURLRef::SearchTermsArgs::SearchTermsArgs(const string16& search_terms)
 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type)
     : owner_(owner),
       type_(type),
+      index_in_owner_(-1),
       parsed_(false),
       valid_(false),
       supports_replacements_(false),
+      search_term_key_location_(url_parse::Parsed::QUERY),
       prepopulated_(false) {
   DCHECK(owner_);
+  DCHECK_NE(INDEXED, type_);
+}
+
+TemplateURLRef::TemplateURLRef(TemplateURL* owner, size_t index_in_owner)
+    : owner_(owner),
+      type_(INDEXED),
+      index_in_owner_(index_in_owner),
+      parsed_(false),
+      valid_(false),
+      supports_replacements_(false),
+      search_term_key_location_(url_parse::Parsed::QUERY),
+      prepopulated_(false) {
+  DCHECK(owner_);
+  DCHECK_LT(index_in_owner_, owner_->URLCount());
 }
 
 TemplateURLRef::~TemplateURLRef() {
@@ -138,6 +176,7 @@ std::string TemplateURLRef::GetURL() const {
     case SEARCH:  return owner_->url();
     case SUGGEST: return owner_->suggestions_url();
     case INSTANT: return owner_->instant_url();
+    case INDEXED: return owner_->GetURL(index_in_owner_);
     default:      NOTREACHED(); return std::string();  // NOLINT
   }
 }
@@ -404,6 +443,56 @@ bool TemplateURLRef::HasGoogleBaseURLs() const {
   return false;
 }
 
+bool TemplateURLRef::ExtractSearchTermsFromURL(const GURL& url,
+                                               string16* search_terms) 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())));
+  // Scheme, host, path and port must match.
+  if (!url.SchemeIs(pattern.scheme().c_str()) ||
+      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());
+  while (url_parse::ExtractQueryKeyValue(params.c_str(), &query, &key,
+                                         &value)) {
+    if (key.is_nonempty()) {
+      if (params.substr(key.begin, key.len) == 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);
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
   host_.clear();
@@ -556,31 +645,24 @@ void TemplateURLRef::ParseHostAndSearchTermKey(
                                kGoogleBaseSuggestURLParameterFull,
                                search_terms_data.GoogleBaseSuggestURLValue());
 
+  search_term_key_.clear();
+  host_.clear();
+  path_.clear();
+  search_term_key_location_ = url_parse::Parsed::REF;
+
   GURL url(url_string);
   if (!url.is_valid())
     return;
 
-  std::string query_string = url.query();
-  if (query_string.empty())
-    return;
-
-  url_parse::Component query, key, value;
-  query.len = static_cast<int>(query_string.size());
-  while (url_parse::ExtractQueryKeyValue(query_string.c_str(), &query, &key,
-                                         &value)) {
-    if (key.is_nonempty() && value.is_nonempty()) {
-      std::string value_string = query_string.substr(value.begin, value.len);
-      if (value_string.find(kSearchTermsParameterFull, 0) !=
-          std::string::npos ||
-          value_string.find(kGoogleUnescapedSearchTermsParameterFull, 0) !=
-          std::string::npos) {
-        search_term_key_ = query_string.substr(key.begin, key.len);
-        host_ = url.host();
-        path_ = url.path();
-        break;
-      }
-    }
-  }
+  std::string query_key = FindSearchTermsKey(url.query());
+  std::string ref_key = FindSearchTermsKey(url.ref());
+  if (query_key.empty() == ref_key.empty())
+    return;  // No key or multiple keys found.  We only handle having one key.
+  search_term_key_ = query_key.empty() ? ref_key : query_key;
+  search_term_key_location_ = query_key.empty() ?
+      url_parse::Parsed::REF : url_parse::Parsed::QUERY;
+  host_ = url.host();
+  path_ = url.path();
 }
 
 
@@ -690,6 +772,41 @@ bool TemplateURL::IsExtensionKeyword() const {
   return GURL(data_.url()).SchemeIs(chrome::kExtensionScheme);
 }
 
+size_t TemplateURL::URLCount() const {
+  // Add 1 for the regular search URL.
+  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) {
+  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;
+}
+
 void TemplateURL::CopyFrom(const TemplateURL& other) {
   if (this == &other)
     return;