Support inexact path matching when extracting terms from Template URL.

components/search_engines/template_url.cc

 // Copyright 2014 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 "components/search_engines/template_url.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 41 matching lines @@
     "google:unescapedSearchTerms";
 const char kGoogleUnescapedSearchTermsParameterFull[] =
     "{google:unescapedSearchTerms}";
 
 // Display value for kSearchTermsParameter.
 const char kDisplaySearchTerms[] = "%s";
 
 // Display value for kGoogleUnescapedSearchTermsParameter.
 const char kDisplayUnescapedSearchTerms[] = "%S";
 
+// Text "{google:ignorePathEnding}" at the end of template path orders to
+// not compare rest of an URL's path while extracting search terms from the URL.
+const char kGoogleIgnorePathEndingFullEscaped[] =
+    "%7Bgoogle:ignorePathEnding%7D";
+
 // Used if the count parameter is not optional. Indicates we want 10 search
 // results.
 const char kDefaultCount[] = "10";
 
 // Used if the output encoding parameter is required.
 const char kOutputEncodingType[] = "UTF-8";
 
 // Attempts to encode |terms| and |original_query| in |encoding| and escape
 // them.  |terms| may be escaped as path or query depending on |is_in_query|;
 // |original_query| is always escaped as query.  Returns whether the encoding
@@ skipping 62 matching lines @@
                               kGoogleUnescapedSearchTermsParameterFull,
                               &result.value_prefix, &result.value_suffix)) {
         result.key = params.substr(key.begin, key.len);
         break;
       }
     }
   }
   return result;
 }
 
+struct SearchTermsInPathResult {
+  bool search_terms_found;
+  std::string value_prefix;
+  std::string value_suffix;
+  bool ignore_ending;
+  SearchTermsInPathResult() : search_terms_found(false), ignore_ending(false) {}
+  bool found() const { return search_terms_found; }
+};
+
 // Extract the position of the search terms' parameter in the URL path.
-bool FindSearchTermsInPath(const std::string& path,
-                           url::Component* parameter_position) {
-  DCHECK(parameter_position);
-  parameter_position->reset();
-  const size_t begin = path.find(kSearchTermsParameterFullEscaped);
-  if (begin == std::string::npos)
-    return false;
-  parameter_position->begin = begin;
-  parameter_position->len = arraysize(kSearchTermsParameterFullEscaped) - 1;
-  return true;
+SearchTermsInPathResult FindSearchTermsInPath(const base::StringPiece& path) {
+  DCHECK(path.starts_with("/"));
+
+  const base::StringPiece search_terms_parameter(
+      kSearchTermsParameterFullEscaped);
+  const size_t search_terms_pos = path.find(search_terms_parameter);
+  const size_t search_terms_end = (search_terms_pos == std::string::npos) ?
+      std::string::npos : (search_terms_pos + search_terms_parameter.length());
+
+  const base::StringPiece ignore_ending_parameter(
+      kGoogleIgnorePathEndingFullEscaped);
+  const size_t ignore_ending_pos = path.find(ignore_ending_parameter);
+
+  bool search_terms_found = (search_terms_pos != std::string::npos);
+  bool ignore_ending = (ignore_ending_pos != std::string::npos);
+  size_t path_end = path.length();
+
+  if (search_terms_found && ignore_ending) {
+    if (ignore_ending_pos < search_terms_pos) {
+      // "{google:ignorePathEnding}" occurs before "{searchTerms}".
+      // Ignore "{searchTerms}".
+      search_terms_found = false;
+    } else if (search_terms_end == ignore_ending_pos) {
+      // No characters occur between "{searchTerms}" and
+      // "{google:ignorePathEnding}". Ignore "{google:ignorePathEnding}".
+      ignore_ending = false;
+      path_end = ignore_ending_pos;
+    }
+  }
+
+  base::StringPiece prefix, suffix;
+  if (search_terms_found) {
+    prefix = path.substr(0, search_terms_pos);
+    if (ignore_ending)
+      suffix = path.substr(search_terms_end,
+                           ignore_ending_pos - search_terms_end);
+    else
+      suffix = path.substr(search_terms_end, path_end - search_terms_end);
+  } else {
+    if (ignore_ending)
+      prefix = path.substr(0, ignore_ending_pos);
+    else
+      prefix = path.substr(0, path_end);
+  }
+
+  SearchTermsInPathResult result;
+  result.search_terms_found = search_terms_found;
+  result.ignore_ending = ignore_ending;
+  result.value_prefix = prefix.as_string();
+  result.value_suffix = suffix.as_string();
+  DCHECK(base::StartsWith(result.value_prefix, "/",
+                          base::CompareCase::SENSITIVE));
+  DCHECK(!result.search_terms_found || !result.ignore_ending ||
+         !result.value_suffix.empty());
+  return result;
 }
 
 bool IsTemplateParameterString(const std::string& param) {
   return (param.length() > 2) && (*(param.begin()) == kStartParameter) &&
       (*(param.rbegin()) == kEndParameter);
 }
 
 }  // namespace
 
 
@@ skipping 68 matching lines @@
 
 // TemplateURLRef -------------------------------------------------------------
 
 TemplateURLRef::TemplateURLRef(const TemplateURL* owner, Type type)
     : owner_(owner),
       type_(type),
       index_in_owner_(0),
       parsed_(false),
       valid_(false),
       supports_replacements_(false),
-      search_term_position_in_path_(std::string::npos),
+      ignore_path_ending_(false),
       search_term_key_location_(url::Parsed::QUERY),
       prepopulated_(false) {
   DCHECK(owner_);
   DCHECK_NE(INDEXED, type_);
 }
 
 TemplateURLRef::TemplateURLRef(const 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_position_in_path_(std::string::npos),
+      ignore_path_ending_(false),
       search_term_key_location_(url::Parsed::QUERY),
       prepopulated_(false) {
   DCHECK(owner_);
   DCHECK_LT(index_in_owner_, owner_->alternate_urls().size());
 }
 
 TemplateURLRef::~TemplateURLRef() {
 }
 
 TemplateURLRef::TemplateURLRef(const TemplateURLRef& source) = default;
@@ skipping 140 matching lines @@
   ParseIfNecessary(search_terms_data);
   return host_;
 }
 
 const std::string& TemplateURLRef::GetPath(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return path_;
 }
 
+bool TemplateURLRef::GetIgnorePathEnding(
+    const SearchTermsData& search_terms_data) const {
+  ParseIfNecessary(search_terms_data);
+  return ignore_path_ending_;
+}
+
 const std::string& TemplateURLRef::GetSearchTermKey(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return search_term_key_;
 }
 
-size_t TemplateURLRef::GetSearchTermPositionInPath(
-    const SearchTermsData& search_terms_data) const {
-  ParseIfNecessary(search_terms_data);
-  return search_term_position_in_path_;
-}
-
 url::Parsed::ComponentType TemplateURLRef::GetSearchTermKeyLocation(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return search_term_key_location_;
 }
 
+const std::string& TemplateURLRef::GetSearchTermValuePrefix(
+    const SearchTermsData& search_terms_data) const {
+  ParseIfNecessary(search_terms_data);
+  return search_term_value_prefix_;
+}
+
+const std::string& TemplateURLRef::GetSearchTermValueSuffix(
+    const SearchTermsData& search_terms_data) const {
+  ParseIfNecessary(search_terms_data);
+  return search_term_value_suffix_;
+}
+
 base::string16 TemplateURLRef::SearchTermToString16(
     const std::string& term) const {
   const std::vector<std::string>& encodings = owner_->input_encodings();
   base::string16 result;
 
   net::UnescapeRule::Type unescape_rules =
       net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS |
       net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS;
   if (search_term_key_location_ != url::Parsed::PATH)
     unescape_rules |= net::UnescapeRule::REPLACE_PLUS_WITH_SPACE;
@@ skipping 42 matching lines @@
   ParseIfNecessary(search_terms_data);
 
   // We need a search term in the template URL to extract something.
   if (search_term_key_.empty() &&
       (search_term_key_location_ != url::Parsed::PATH))
     return false;
 
   // Host, port, and path must match.
   if ((url.host() != host_) ||
       (url.port() != port_) ||
-      ((url.path() != path_) &&
-          (search_term_key_location_ != url::Parsed::PATH))) {
+      ((search_term_key_location_ != url::Parsed::PATH) &&
+          !MatchPath(url.path()))) {
     return false;
   }
 
   std::string source;
   url::Component position;
 
   if (search_term_key_location_ == url::Parsed::PATH) {
     source = url.path();
-
-    // Characters in the path before and after search terms must match.
-    if (source.length() < path_.length())
-      return false;
-    position.begin = search_term_position_in_path_;
-    position.len = source.length() - path_.length();
-    if (source.substr(0, position.begin) + source.substr(position.end()) !=
-        path_)
+    if (!MatchPathWithSearchTerms(source, &position))
       return false;
   } else {
     DCHECK(search_term_key_location_ == url::Parsed::QUERY ||
            search_term_key_location_ == url::Parsed::REF);
     source = (search_term_key_location_ == url::Parsed::QUERY) ?
         url.query() : url.ref();
 
     url::Component query, key, value;
     query.len = static_cast<int>(source.size());
     bool key_found = false;
@@ skipping 26 matching lines @@
   // Extract the search term.
   *search_terms =
       SearchTermToString16(source.substr(position.begin, position.len));
   if (search_terms_component)
     *search_terms_component = search_term_key_location_;
   if (search_terms_position)
     *search_terms_position = position;
   return true;
 }
 
+bool TemplateURLRef::MatchPath(const std::string& path) const {
+  if (search_term_key_location_ == url::Parsed::PATH)
+    return false;
+  if (ignore_path_ending_)
+    return base::StartsWith(path, path_, base::CompareCase::SENSITIVE);
+  else
+    return (path == path_);
+}
+
+bool TemplateURLRef::MatchPathWithSearchTerms(
+    const std::string& path,
+    url::Component* search_terms_position) const {
+  if (search_term_key_location_ != url::Parsed::PATH)
+    return false;
+  if (path.length() < search_term_value_prefix_.length() +
+      search_term_value_suffix_.length())
+    return false;
+  if (!base::StartsWith(path, search_term_value_prefix_,
+                        base::CompareCase::SENSITIVE))
+    return false;
+  const size_t search_terms_pos = search_term_value_prefix_.length();
+  size_t search_terms_end = std::string::npos;
+  if (ignore_path_ending_) {
+    search_terms_end = path.find(search_term_value_suffix_,
+                                 search_terms_pos);
+    if (search_terms_end == std::string::npos)
+      return false;
+  } else {
+    if (!base::EndsWith(path, search_term_value_suffix_,
+                        base::CompareCase::SENSITIVE))
+      return false;
+    search_terms_end = path.length() - search_term_value_suffix_.length();
+  }
+  DCHECK_NE(std::string::npos, search_terms_end);
+  *search_terms_position = url::MakeRange(search_terms_pos, search_terms_end);
+  return true;
+}
+
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
   host_.clear();
   port_.clear();
   path_.clear();
+  ignore_path_ending_ = false;
   search_term_key_.clear();
-  search_term_position_in_path_ = std::string::npos;
   search_term_key_location_ = url::Parsed::QUERY;
+  search_term_value_prefix_.clear();
+  search_term_value_suffix_.clear();
   replacements_.clear();
   post_params_.clear();
 }
 
 bool TemplateURLRef::ParseParameter(size_t start,
                                     size_t end,
                                     std::string* url,
                                     Replacements* replacements) const {
   DCHECK(start != std::string::npos &&
          end != std::string::npos && end > start);
@@ skipping 232 matching lines @@
   base::ReplaceSubstringsAfterOffset(
       &url_string, 0, "{google:baseSuggestURL}",
       search_terms_data.GoogleBaseSuggestURLValue());
 
   GURL url(url_string);
   if (!url.is_valid())
     return;
 
   auto query_result = FindSearchTermsKey(url.query());
   auto ref_result = FindSearchTermsKey(url.ref());
-  url::Component parameter_position;
+  auto path_result = FindSearchTermsInPath(url.path());
   const bool in_query = query_result.found();
   const bool in_ref = ref_result.found();
-  const bool in_path = FindSearchTermsInPath(url.path(), &parameter_position);
+  const bool in_path = path_result.found();
   if (in_query ? (in_ref || in_path) : (in_ref == in_path))
     return;  // No key or multiple keys found.  We only handle having one key.
 
   host_ = url.host();
   port_ = url.port();
-  path_ = url.path();
+  path_ = path_result.value_prefix + path_result.value_suffix;
+  ignore_path_ending_ = path_result.ignore_ending;
   if (in_query) {
     search_term_key_ = query_result.key;
     search_term_key_location_ = url::Parsed::QUERY;
     search_term_value_prefix_ = query_result.value_prefix;
     search_term_value_suffix_ = query_result.value_suffix;
   } else if (in_ref) {
     search_term_key_ = ref_result.key;
     search_term_key_location_ = url::Parsed::REF;
     search_term_value_prefix_ = ref_result.value_prefix;
     search_term_value_suffix_ = ref_result.value_suffix;
   } else {
     DCHECK(in_path);
-    DCHECK_GE(parameter_position.begin, 1);  // Path must start with '/'.
     search_term_key_location_ = url::Parsed::PATH;
-    search_term_position_in_path_ = parameter_position.begin;
-    // Remove the "{searchTerms}" itself from |path_|.
-    path_.erase(parameter_position.begin, parameter_position.len);
+    search_term_value_prefix_ = path_result.value_prefix;
+    search_term_value_suffix_ = path_result.value_suffix;
   }
 }
 
 void TemplateURLRef::HandleReplacement(const std::string& name,
                                        const std::string& value,
                                        const Replacement& replacement,
                                        std::string* url) const {
   size_t pos = replacement.index;
   if (replacement.is_post_param) {
     DCHECK_LT(pos, post_params_.size());
@@ skipping 676 matching lines @@
       // 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;
 }