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

components/error_page/renderer/net_error_helper_core.cc

 // Copyright 2013 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/error_page/renderer/net_error_helper_core.h"
 
 #include <stddef.h>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 242 matching lines @@
   params->SetString("clickType", correction.click_type);
   params->SetString("clickData", correction.click_data);
 
   params->SetString("eventId", response.event_id);
   params->SetString("fingerprint", response.fingerprint);
 
   return CreateRequestBody("linkdoctor.fixurl.clicktracking", error_param,
                            correction_params, std::move(params));
 }
 
-base::string16 FormatURLForDisplay(const GURL& url, bool is_rtl,
-                                   const std::string accept_languages) {
+base::string16 FormatURLForDisplay(const GURL& url, bool is_rtl) {
   // Translate punycode into UTF8, unescape UTF8 URLs.
   base::string16 url_for_display(url_formatter::FormatUrl(
-      url, accept_languages, url_formatter::kFormatUrlOmitNothing,
+      url, url_formatter::kFormatUrlOmitNothing,
       net::UnescapeRule::NORMAL, nullptr, nullptr, nullptr));
   // URLs are always LTR.
   if (is_rtl)
     base::i18n::WrapStringWithLTRFormatting(&url_for_display);
   return url_for_display;
 }
 
 scoped_ptr<NavigationCorrectionResponse> ParseNavigationCorrectionResponse(
     const std::string raw_response) {
   // TODO(mmenke):  Open source related protocol buffers and use them directly.
   scoped_ptr<base::Value> parsed = base::JSONReader::Read(raw_response);
   scoped_ptr<NavigationCorrectionResponse> response(
       new NavigationCorrectionResponse());
   base::JSONValueConverter<NavigationCorrectionResponse> converter;
   if (!parsed || !converter.Convert(*parsed, response.get()))
     response.reset();
   return response;
 }
 
 void LogCorrectionTypeShown(int type_id) {
   UMA_HISTOGRAM_ENUMERATION(
       "Net.ErrorPageCounts.NavigationCorrectionLinksShown", type_id,
       kWebSearchQueryUMAId + 1);
 }
 
 scoped_ptr<ErrorPageParams> CreateErrorPageParams(
     const NavigationCorrectionResponse& response,
     const blink::WebURLError& error,
     const NetErrorHelperCore::NavigationCorrectionParams& correction_params,
-    const std::string& accept_languages,
     bool is_rtl) {
   // Version of URL for display in suggestions.  It has to be sanitized first
   // because any received suggestions will be relative to the sanitized URL.
   base::string16 original_url_for_display =
-      FormatURLForDisplay(SanitizeURL(GURL(error.unreachableURL)), is_rtl,
-                          accept_languages);
+      FormatURLForDisplay(SanitizeURL(GURL(error.unreachableURL)), is_rtl);
 
   scoped_ptr<ErrorPageParams> params(new ErrorPageParams());
   params->override_suggestions.reset(new base::ListValue());
   scoped_ptr<base::ListValue> parsed_corrections(new base::ListValue());
   for (ScopedVector<NavigationCorrection>::const_iterator it =
            response.corrections.begin();
        it != response.corrections.end(); ++it) {
     // Doesn't seem like a good idea to show these.
     if ((*it)->is_porn || (*it)->is_soft_porn)
       continue;
@@ skipping 33 matching lines @@
               kCorrectionResourceTable[correction_index].correction_type) {
         continue;
       }
       base::DictionaryValue* suggest = new base::DictionaryValue();
       suggest->SetString("summary",
           l10n_util::GetStringUTF16(
               kCorrectionResourceTable[correction_index].resource_id));
       suggest->SetString("urlCorrection", (*it)->url_correction);
       suggest->SetString(
           "urlCorrectionForDisplay",
-          FormatURLForDisplay(GURL((*it)->url_correction), is_rtl,
-                              accept_languages));
+          FormatURLForDisplay(GURL((*it)->url_correction), is_rtl));
       suggest->SetString("originalUrlForDisplay", original_url_for_display);
       suggest->SetInteger("trackingId", tracking_id);
       suggest->SetInteger("type", static_cast<int>(correction_index));
 
       params->override_suggestions->Append(suggest);
       LogCorrectionTypeShown(static_cast<int>(correction_index));
       break;
     }
   }
 
@@ skipping 444 matching lines @@
   // by a DNS error update.
   delegate_->UpdateErrorPage(
       GetUpdatedError(committed_error_page_info_->error),
       committed_error_page_info_->was_failed_post,
       can_show_network_diagnostics_dialog_,
       HasOfflinePages());
 }
 
 void NetErrorHelperCore::OnNavigationCorrectionsFetched(
     const std::string& corrections,
-    const std::string& accept_languages,
     bool is_rtl) {
   // Loading suggestions only starts when a blank error page finishes loading,
   // and is cancelled with a new load.
   DCHECK(!pending_error_page_info_);
   DCHECK(committed_error_page_info_->is_finished_loading);
   DCHECK(committed_error_page_info_->needs_load_navigation_corrections);
   DCHECK(committed_error_page_info_->navigation_correction_params);
 
   pending_error_page_info_.reset(new ErrorPageInfo(
       committed_error_page_info_->error,
       committed_error_page_info_->was_failed_post,
       committed_error_page_info_->was_ignoring_cache));
   pending_error_page_info_->navigation_correction_response =
       ParseNavigationCorrectionResponse(corrections);
 
   std::string error_html;
   scoped_ptr<ErrorPageParams> params;
   if (pending_error_page_info_->navigation_correction_response) {
     // Copy navigation correction parameters used for the request, so tracking
     // requests can still be sent if the configuration changes.
     pending_error_page_info_->navigation_correction_params.reset(
         new NavigationCorrectionParams(
             *committed_error_page_info_->navigation_correction_params));
     params = CreateErrorPageParams(
           *pending_error_page_info_->navigation_correction_response,
           pending_error_page_info_->error,
-          *pending_error_page_info_->navigation_correction_params,
-          accept_languages, is_rtl);
+          *pending_error_page_info_->navigation_correction_params, is_rtl);
     delegate_->GenerateLocalizedErrorPage(
         pending_error_page_info_->error,
         pending_error_page_info_->was_failed_post,
         can_show_network_diagnostics_dialog_, HasOfflinePages(),
         std::move(params), &pending_error_page_info_->reload_button_in_page,
         &pending_error_page_info_->show_saved_copy_button_in_page,
         &pending_error_page_info_->show_cached_copy_button_in_page,
         &pending_error_page_info_->show_offline_pages_button_in_page,
         &error_html);
   } else {
@@ skipping 209 matching lines @@
 
 bool NetErrorHelperCore::HasOfflinePages() const {
 #if defined(OS_ANDROID)
   return has_offline_pages_;
 #else
   return false;
 #endif  // defined(OS_ANDROID)
 }
 
 }  // namespace error_page