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

components/omnibox/browser/history_url_provider.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 "components/omnibox/browser/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 405 matching lines @@
     // different port and/or path) before.
     url_row_ = history::URLRow(url);
     type_ = UNVISITED_INTRANET;
   }
 }
 
 HistoryURLProviderParams::HistoryURLProviderParams(
     const AutocompleteInput& input,
     bool trim_http,
     const AutocompleteMatch& what_you_typed_match,
-    const std::string& languages,
     TemplateURL* default_search_provider,
     const SearchTermsData& search_terms_data)
     : message_loop(base::MessageLoop::current()),
       input(input),
       prevent_inline_autocomplete(input.prevent_inline_autocomplete()),
       trim_http(trim_http),
       what_you_typed_match(what_you_typed_match),
       failed(false),
       exact_suggestion_is_in_history(false),
       promote_type(NEITHER),
-      languages(languages),
       default_search_provider(default_search_provider ?
           new TemplateURL(default_search_provider->data()) : NULL),
       search_terms_data(new SearchTermsDataSnapshot(search_terms_data)) {
 }
 
 HistoryURLProviderParams::~HistoryURLProviderParams() {
 }
 
 HistoryURLProvider::HistoryURLProvider(AutocompleteProviderClient* client,
                                        AutocompleteProviderListener* listener)
@@ skipping 63 matching lines @@
   // thread. |template_url_service| can be NULL when testing.
   TemplateURLService* template_url_service = client()->GetTemplateURLService();
   TemplateURL* default_search_provider = template_url_service ?
       template_url_service->GetDefaultSearchProvider() : NULL;
 
   // Create the data structure for the autocomplete passes.  We'll save this off
   // onto the |params_| member for later deletion below if we need to run pass
   // 2.
   scoped_ptr<HistoryURLProviderParams> params(new HistoryURLProviderParams(
       fixed_up_input, trim_http, what_you_typed_match,
-      client()->GetAcceptLanguages(), default_search_provider,
-      client()->GetSearchTermsData()));
+      default_search_provider, client()->GetSearchTermsData()));
   // Note that we use the non-fixed-up input here, since fixup may strip
   // trailing whitespace.
   params->prevent_inline_autocomplete = PreventInlineAutocomplete(input);
 
   // Pass 1: Get the in-memory URL database, and use it to find and promote
   // the inline autocomplete match, if any.
   history::URLDatabase* url_db = history_service->InMemoryDatabase();
   // url_db can be NULL if it hasn't finished initializing (or failed to
   // initialize).  In this case all we can do is fall back on the second
   // pass.
@@ skipping 40 matching lines @@
   AutocompleteMatch match(this, 0, false,
                           AutocompleteMatchType::URL_WHAT_YOU_TYPED);
 
   if (destination_url.is_valid()) {
     match.destination_url = destination_url;
 
     // Trim off "http://" if the user didn't type it.
     DCHECK(!trim_http ||
            !AutocompleteInput::HasHTTPScheme(input.text()));
     base::string16 display_string(url_formatter::FormatUrl(
-        destination_url, std::string(),
+        destination_url,
         url_formatter::kFormatUrlOmitAll & ~url_formatter::kFormatUrlOmitHTTP,
         net::UnescapeRule::SPACES, nullptr, nullptr, nullptr));
     const size_t offset = trim_http ? TrimHttpPrefix(&display_string) : 0;
     match.fill_into_edit =
         AutocompleteInput::FormattedStringWithEquivalentMeaning(
             destination_url, display_string, client()->GetSchemeClassifier());
     // The what-you-typed match is generally only allowed to be default for
     // URL inputs.  (It's also allowed to be default for UNKNOWN inputs
     // where the destination is a known intranet site.  In this case,
     // |allowed_to_be_default_match| is revised in FixupExactSuggestion().)
@@ skipping 217 matching lines @@
     params->matches.resize(max_results);
   }
 }
 
 void HistoryURLProvider::PromoteMatchesIfNecessary(
     const HistoryURLProviderParams& params) {
   if (params.promote_type == HistoryURLProviderParams::NEITHER)
     return;
   if (params.promote_type == HistoryURLProviderParams::FRONT_HISTORY_MATCH) {
     matches_.push_back(
-        HistoryMatchToACMatch(params, 0, INLINE_AUTOCOMPLETE,
+        HistoryMatchToACMatch(params, 0,
                               CalculateRelevance(INLINE_AUTOCOMPLETE, 0)));
   }
   // There are two cases where we need to add the what-you-typed-match:
   //   * If params.promote_type is WHAT_YOU_TYPED_MATCH, we're being explicitly
   //     directed to.
   //   * If params.have_what_you_typed_match is true, then params.promote_type
   //     can't be NEITHER (see code near the end of DoAutocomplete()), so if
   //     it's not WHAT_YOU_TYPED_MATCH, it must be FRONT_HISTORY_MATCH, and
   //     we'll have promoted the history match above.  If
   //     params.prevent_inline_autocomplete is also true, then this match
@@ skipping 43 matching lines @@
          (params->promote_type ==
              HistoryURLProviderParams::FRONT_HISTORY_MATCH)) ? 1 : 0;
     for (size_t i = first_match; i < params->matches.size(); ++i) {
       // All matches score one less than the previous match.
       --relevance;
       // The experimental scoring must not change the top result's score.
       if (!matches_.empty()) {
         relevance = CalculateRelevanceScoreUsingScoringParams(
             params->matches[i], relevance, scoring_params_);
       }
-      matches_.push_back(HistoryMatchToACMatch(*params, i, NORMAL, relevance));
+      matches_.push_back(HistoryMatchToACMatch(*params, i, relevance));
     }
   }
 
   done_ = true;
   listener_->OnProviderUpdate(true);
 }
 
 bool HistoryURLProvider::FixupExactSuggestion(
     history::URLDatabase* db,
     const VisitClassifier& classifier,
@@ skipping 233 matching lines @@
     next = matches->erase(next);
     if (static_cast<size_t>(next - matches->begin()) < next_index)
       --next_index;
   }
   return next_index;
 }
 
 AutocompleteMatch HistoryURLProvider::HistoryMatchToACMatch(
     const HistoryURLProviderParams& params,
     size_t match_number,
-    MatchType match_type,
     int relevance) {
   // The FormattedStringWithEquivalentMeaning() call below requires callers to
   // be on the main thread.
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const history::HistoryMatch& history_match = params.matches[match_number];
   const history::URLRow& info = history_match.url_info;
   AutocompleteMatch match(this, relevance,
       !!info.visit_count(), AutocompleteMatchType::HISTORY_URL);
   match.typed_count = info.typed_count();
   match.destination_url = info.url();
   DCHECK(match.destination_url.is_valid());
   size_t inline_autocomplete_offset =
       history_match.input_location + params.input.text().length();
-  std::string languages = (match_type == WHAT_YOU_TYPED) ?
-      std::string() : params.languages;
   const url_formatter::FormatUrlTypes format_types =
       url_formatter::kFormatUrlOmitAll &
       ~((params.trim_http && !history_match.match_in_scheme)
             ? 0
             : url_formatter::kFormatUrlOmitHTTP);
   match.fill_into_edit =
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           info.url(),
-          url_formatter::FormatUrl(info.url(), languages, format_types,
+          url_formatter::FormatUrl(info.url(), format_types,
                                    net::UnescapeRule::SPACES, nullptr, nullptr,
                                    &inline_autocomplete_offset),
           client()->GetSchemeClassifier());
   // |inline_autocomplete_offset| was guaranteed not to be npos before the call
   // to FormatUrl().  If it is npos now, that means the represented location no
   // longer exists as such in the formatted string, e.g. if the offset pointed
   // into the middle of a punycode sequence fixed up to Unicode.  In this case,
   // there can be no inline autocompletion, and the match must not be allowed to
   // be default.
   const bool autocomplete_offset_valid =
       inline_autocomplete_offset != base::string16::npos;
   if (!params.prevent_inline_autocomplete && autocomplete_offset_valid) {
     DCHECK(inline_autocomplete_offset <= match.fill_into_edit.length());
     match.inline_autocompletion =
         match.fill_into_edit.substr(inline_autocomplete_offset);
   }
   // The latter part of the test effectively asks "is the inline completion
   // empty?" (i.e., is this match effectively the what-you-typed match?).
   match.allowed_to_be_default_match = autocomplete_offset_valid &&
       (!params.prevent_inline_autocomplete ||
        (inline_autocomplete_offset >= match.fill_into_edit.length()));
 
   size_t match_start = history_match.input_location;
-  match.contents = url_formatter::FormatUrl(info.url(), languages, format_types,
+  match.contents = url_formatter::FormatUrl(info.url(), format_types,
                                             net::UnescapeRule::SPACES, nullptr,
                                             nullptr, &match_start);
   if ((match_start != base::string16::npos) && autocomplete_offset_valid &&
       (inline_autocomplete_offset != match_start)) {
     DCHECK(inline_autocomplete_offset > match_start);
     AutocompleteMatch::ClassifyLocationInString(match_start,
         inline_autocomplete_offset - match_start, match.contents.length(),
         ACMatchClassification::URL, &match.contents_class);
   } else {
     AutocompleteMatch::ClassifyLocationInString(base::string16::npos, 0,
         match.contents.length(), ACMatchClassification::URL,
         &match.contents_class);
   }
   match.description = info.title();
   match.description_class =
       ClassifyDescription(params.input.text(), match.description);
   RecordAdditionalInfoFromUrlRow(info, &match);
   return match;
 }