Fixed ExtractSearchTermsFromURL for search engines with encoding != "UTF-8".

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/basictypes.h"
@@ skipping 441 matching lines @@
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   return search_term_key_location_;
 }
 
 base::string16 TemplateURLRef::SearchTermToString16(
     const std::string& term) const {
   const std::vector<std::string>& encodings = owner_->input_encodings();
   base::string16 result;
 
-  std::string unescaped = net::UnescapeURLComponent(
-      term,
-      net::UnescapeRule::REPLACE_PLUS_WITH_SPACE |
-      net::UnescapeRule::URL_SPECIAL_CHARS);
+  net::UnescapeRule::Type unescape_rules =
+      net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS;
+  if (search_term_key_location_ != url::Parsed::PATH)
+    unescape_rules |= net::UnescapeRule::REPLACE_PLUS_WITH_SPACE;
+
+  std::string unescaped = net::UnescapeURLComponent(term, unescape_rules);
   for (size_t i = 0; i < encodings.size(); ++i) {
     if (base::CodepageToUTF16(unescaped, encodings[i].c_str(),
                               base::OnStringConversionError::FAIL, &result))
       return result;
   }
 
   // Always fall back on UTF-8 if it works.
   if (base::CodepageToUTF16(unescaped, base::kCodepageUTF8,
                             base::OnStringConversionError::FAIL, &result))
     return result;
 
   // When nothing worked, just use the escaped text. We have no idea what the
   // encoding is. We need to substitute spaces for pluses ourselves since we're
   // not sending it through an unescaper.
   result = base::UTF8ToUTF16(term);
-  std::replace(result.begin(), result.end(), '+', ' ');
+  if (unescape_rules & net::UnescapeRule::REPLACE_PLUS_WITH_SPACE)
+    std::replace(result.begin(), result.end(), '+', ' ');
   return result;
 }
 
 bool TemplateURLRef::HasGoogleBaseURLs(
     const SearchTermsData& search_terms_data) const {
   ParseIfNecessary(search_terms_data);
   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;
@@ skipping 25 matching lines @@
   // Host, path and port must match.
   if ((url.port() != pattern.port()) ||
       (url.host() != host_) ||
       ((url.path() != path_) &&
           (search_term_key_location_ != url::Parsed::PATH))) {
     return false;
   }
 
   std::string source;
   url::Component position;
-  net::UnescapeRule::Type unescape_rules =
-      net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS;
 
   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()) !=
@@ skipping 14 matching lines @@
           // Fail if search term key is found twice.
           if (key_found)
             return false;
           key_found = true;
           position = value;
         }
       }
     }
     if (!key_found)
       return false;
-    unescape_rules |= net::UnescapeRule::REPLACE_PLUS_WITH_SPACE;
   }
 
   // Extract the search term.
-  *search_terms = net::UnescapeAndDecodeUTF8URLComponent(
-      source.substr(position.begin, position.len), unescape_rules);
+  *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;
 }
 
 void TemplateURLRef::InvalidateCachedValues() const {
   supports_replacements_ = valid_ = parsed_ = false;
   host_.clear();
@@ skipping 964 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;
 }