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

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/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/rtl.h"
@@ skipping 105 matching lines @@
     : search_terms(search_terms),
       accepted_suggestion(NO_SUGGESTIONS_AVAILABLE) {
 }
 
 
 // TemplateURLRef -------------------------------------------------------------
 
 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() {
 }
 
 std::string TemplateURLRef::GetURL() const {
   switch (type_) {
     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
   }
 }
 
 bool TemplateURLRef::SupportsReplacement() const {
   UIThreadSearchTermsData search_terms_data(owner_->profile());
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURLRef::SupportsReplacementUsingTermsData(
@@ skipping 246 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 {
+  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();
   path_.clear();
   search_term_key_.clear();
   replacements_.clear();
 }
 
 bool TemplateURLRef::ParseParameter(size_t start,
                                     size_t end,
@@ skipping 132 matching lines @@
 void TemplateURLRef::ParseHostAndSearchTermKey(
     const SearchTermsData& search_terms_data) const {
   std::string url_string(GetURL());
   ReplaceSubstringsAfterOffset(&url_string, 0,
                                kGoogleBaseURLParameterFull,
                                search_terms_data.GoogleBaseURLValue());
   ReplaceSubstringsAfterOffset(&url_string, 0,
                                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;
+  if (!url.ref().empty())

[Peter Kasting, 2012/10/04 19:32:43]

Nit: This might be slightly clearer if we move the empty() check to
FindSearchTermsKey(), and have that function return the string it finds instead
of setting a member directly.  We can also then avoid any appearance of
favoritism for the ref over the query.  Something like this:

  ...
  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();
}

std::string TemplateURLRef::FindSearchTermsKey(
    const std::string& params) const {
  if (params.empty())
    return std::string();
  while (...) {
    ...
    return params.substr(key.begin, key.len);
    ...
  }
  return std::string();
}

[beaudoin, 2012/10/04 23:10:45]

Much cleaner!

Moved FindSearchTermsKey to the anonymous namespace as it was no longer
dependent on anything in the object.

Done.

+    FindSearchTermsKey(url.ref());
 
+  // If not found in ref string, look for them in query.
+  if (search_term_key_.empty() && !url.query().empty()) {
+    search_term_key_location_ = url_parse::Parsed::QUERY;
+    FindSearchTermsKey(url.query());
+  }
+
+  if (!search_term_key_.empty()) {
+    host_ = url.host();
+    path_ = url.path();
+  }
+}
+
+void TemplateURLRef::FindSearchTermsKey(const std::string& params) const {
   url_parse::Component query, key, value;
-  query.len = static_cast<int>(query_string.size());
-  while (url_parse::ExtractQueryKeyValue(query_string.c_str(), &query, &key,
+  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 = query_string.substr(value.begin, value.len);
+      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) {
-        search_term_key_ = query_string.substr(key.begin, key.len);
-        host_ = url.host();
-        path_ = url.path();
+        search_term_key_ = params.substr(key.begin, key.len);
         break;
       }
     }
   }
 }
 
 
 // TemplateURLData ------------------------------------------------------------
 
 TemplateURLData::TemplateURLData()
@@ skipping 93 matching lines @@
 
 std::string TemplateURL::GetExtensionId() const {
   DCHECK(IsExtensionKeyword());
   return GURL(data_.url()).host();
 }
 
 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

[Peter Kasting, 2012/10/04 19:32:43]

Nit: This comment helps.  I might add even more justification:

      ...
      // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' will
      // return false.  This is important for at least Google, where such URLs
      // are invalid.

[beaudoin, 2012/10/04 23:10:45]

Done.

+      //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
+      // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
+      // return false.
+      return !search_terms->empty();
+    }
+  }
+  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));
   }
 }