Drop |languages| from {Format,Elide}Url* and IDNToUnicode

components/omnibox/browser/search_suggestion_parser.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/omnibox/browser/search_suggestion_parser.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 210 matching lines @@
 
 SearchSuggestionParser::NavigationResult::NavigationResult(
     const AutocompleteSchemeClassifier& scheme_classifier,
     const GURL& url,
     AutocompleteMatchType::Type type,
     const base::string16& description,
     const std::string& deletion_url,
     bool from_keyword_provider,
     int relevance,
     bool relevance_from_server,
-    const base::string16& input_text,
-    const std::string& languages)
+    const base::string16& input_text)
     : Result(from_keyword_provider,
              relevance,
              relevance_from_server,
              type,
              deletion_url),
       url_(url),
       formatted_url_(AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url,
           url_formatter::FormatUrl(url,
-                                   languages,
                                    url_formatter::kFormatUrlOmitAll &
                                        ~url_formatter::kFormatUrlOmitHTTP,
                                    net::UnescapeRule::SPACES,
                                    nullptr,
                                    nullptr,
                                    nullptr),
           scheme_classifier)),
       description_(description) {
   DCHECK(url_.is_valid());
-  CalculateAndClassifyMatchContents(true, input_text, languages);
+  CalculateAndClassifyMatchContents(true, input_text);
 }
 
 SearchSuggestionParser::NavigationResult::~NavigationResult() {}
 
 void
 SearchSuggestionParser::NavigationResult::CalculateAndClassifyMatchContents(
     const bool allow_bolding_nothing,
-    const base::string16& input_text,
-    const std::string& languages) {
+    const base::string16& input_text) {
   if (input_text.empty()) {
     // In case of zero-suggest results, do not highlight matches.
     match_contents_class_.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     return;
   }
 
   // First look for the user's input inside the formatted url as it would be
   // without trimming the scheme, so we can find matches at the beginning of the
   // scheme.
   const URLPrefix* prefix =
       URLPrefix::BestURLPrefix(formatted_url_, input_text);
   size_t match_start = (prefix == NULL) ?
       formatted_url_.find(input_text) : prefix->prefix.length();
   bool trim_http = !AutocompleteInput::HasHTTPScheme(input_text) &&
                    (!prefix || (match_start != 0));
   const url_formatter::FormatUrlTypes format_types =
       url_formatter::kFormatUrlOmitAll &
       ~(trim_http ? 0 : url_formatter::kFormatUrlOmitHTTP);
 
   base::string16 match_contents = url_formatter::FormatUrl(
-      url_, languages, format_types, net::UnescapeRule::SPACES, nullptr,
+      url_, format_types, net::UnescapeRule::SPACES, nullptr,
       nullptr, &match_start);
   // If the first match in the untrimmed string was inside a scheme that we
   // trimmed, look for a subsequent match.
   if (match_start == base::string16::npos)
     match_start = match_contents.find(input_text);
   // Update |match_contents_| and |match_contents_class_| if it's allowed.
   if (allow_bolding_nothing || (match_start != base::string16::npos)) {
     match_contents_ = match_contents;
     // Safe if |match_start| is npos; also safe if the input is longer than the
     // remaining contents after |match_start|.
@@ skipping 92 matching lines @@
   }
   return scoped_ptr<base::Value>();
 }
 
 // static
 bool SearchSuggestionParser::ParseSuggestResults(
     const base::Value& root_val,
     const AutocompleteInput& input,
     const AutocompleteSchemeClassifier& scheme_classifier,
     int default_result_relevance,
-    const std::string& languages,
     bool is_keyword_result,
     Results* results) {
   base::string16 query;
   const base::ListValue* root_list = NULL;
   const base::ListValue* results_list = NULL;
 
   if (!root_val.GetAsList(&root_list) || !root_list->GetString(0, &query) ||
       query != input.text() || !root_list->GetList(1, &results_list))
     return false;
 
@@ skipping 79 matching lines @@
         (match_type == AutocompleteMatchType::NAVSUGGEST_PERSONALIZED)) {
       // Do not blindly trust the URL coming from the server to be valid.
       GURL url(url_formatter::FixupURL(base::UTF16ToUTF8(suggestion),
                                        std::string()));
       if (url.is_valid() && allow_navsuggest) {
         base::string16 title;
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         results->navigation_results.push_back(NavigationResult(
             scheme_classifier, url, match_type, title, deletion_url,
-            is_keyword_result, relevance, relevances != NULL, input.text(),
-            languages));
+            is_keyword_result, relevance, relevances != NULL, input.text()));
       }
     } else {
       // TODO(dschuyler) If the "= " is no longer sent from the back-end
       // then this may be removed.
       if ((match_type == AutocompleteMatchType::CALCULATOR) &&
           !suggestion.compare(0, 2, base::UTF8ToUTF16("= ")))
         suggestion.erase(0, 2);
 
       base::string16 match_contents = suggestion;
       base::string16 match_contents_prefix;
@@ skipping 45 matching lines @@
           base::CollapseWhitespace(match_contents, false),
           match_contents_prefix, annotation, answer_contents, answer_type_str,
           std::move(answer), suggest_query_params, deletion_url,
           is_keyword_result, relevance, relevances != NULL, should_prefetch,
           trimmed_input));
     }
   }
   results->relevances_from_server = relevances != NULL;
   return true;
 }