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

components/url_formatter/elide_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/url_formatter/elide_url.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
@@ skipping 90 matching lines @@
     *url_subdomain = url_host->substr(0, domain_start_index);
   if ((*url_subdomain == kWwwPrefix || url_subdomain->empty() ||
        url.SchemeIsFile())) {
     url_subdomain->clear();
   }
 }
 
 #endif  // !defined(OS_ANDROID)
 
 base::string16 FormatUrlForSecurityDisplayInternal(const GURL& url,
-                                                   const std::string& languages,
                                                    bool omit_scheme) {
   if (!url.is_valid() || url.is_empty() || !url.IsStandard())
-    return url_formatter::FormatUrl(url, languages);
+    return url_formatter::FormatUrl(url);
 
   const base::string16 colon(base::ASCIIToUTF16(":"));
   const base::string16 scheme_separator(
       base::ASCIIToUTF16(url::kStandardSchemeSeparator));
 
   if (url.SchemeIsFile()) {
     return base::ASCIIToUTF16(url::kFileScheme) + scheme_separator +
            base::UTF8ToUTF16(url.path());
   }
 
   if (url.SchemeIsFileSystem()) {
     const GURL* inner_url = url.inner_url();
     if (inner_url->SchemeIsFile()) {
       return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
-             FormatUrlForSecurityDisplayInternal(*inner_url, languages,
+             FormatUrlForSecurityDisplayInternal(*inner_url,
                                                  false /*omit_scheme*/) +

[Peter Kasting, 2016/04/05 02:42:33]

Nit: While here, I'd remove the /*omit_scheme*/ on these two calls and rewrap;
the declaration is just above this so it's not hard for someone to see what that
second arg means, especially now that we have fewer args.

[jungshik at Google, 2016/04/05 18:56:19]

Done.

              base::UTF8ToUTF16(url.path());
     }
     return base::ASCIIToUTF16(url::kFileSystemScheme) + colon +
-           FormatUrlForSecurityDisplayInternal(*inner_url, languages,
+           FormatUrlForSecurityDisplayInternal(*inner_url,
                                                false /*omit_scheme*/);
   }
 
   const GURL origin = url.GetOrigin();
   const std::string& scheme = origin.scheme();
   const std::string& host = origin.host();
 
   base::string16 result;
   if (!omit_scheme || !url.SchemeIsHTTPOrHTTPS())
     result = base::UTF8ToUTF16(scheme) + scheme_separator;
@@ skipping 13 matching lines @@
 namespace url_formatter {
 
 #if !defined(OS_ANDROID)
 
 // TODO(pkasting): http://crbug.com/77883 This whole function gets
 // kerning/ligatures/etc. issues potentially wrong by assuming that the width of
 // a rendered string is always the sum of the widths of its substrings.  Also I
 // suspect it could be made simpler.
 base::string16 ElideUrl(const GURL& url,
                         const gfx::FontList& font_list,
-                        float available_pixel_width,
-                        const std::string& languages) {
+                        float available_pixel_width) {
   // Get a formatted string and corresponding parsing of the url.
   url::Parsed parsed;
   const base::string16 url_string = url_formatter::FormatUrl(
-      url, languages, url_formatter::kFormatUrlOmitAll,
+      url, url_formatter::kFormatUrlOmitAll,
       net::UnescapeRule::SPACES, &parsed, nullptr, nullptr);
   if (available_pixel_width <= 0)
     return url_string;
 
   // If non-standard, return plain eliding.
   if (!url.IsStandard())
     return gfx::ElideText(url_string, font_list, available_pixel_width,
                           gfx::ELIDE_TAIL);
 
   // Now start eliding url_string to fit within available pixel width.
@@ skipping 167 matching lines @@
   float subdomain_width = available_pixel_width - pixel_width_url_domain;
   if (subdomain_width <= 0)
     return base::string16(gfx::kEllipsisUTF16) + kDot + url_domain;
 
   return gfx::ElideText(url_host, font_list, available_pixel_width,
                         gfx::ELIDE_HEAD);
 }
 
 #endif  // !defined(OS_ANDROID)
 
-base::string16 FormatUrlForSecurityDisplay(const GURL& url,
-                                           const std::string& languages) {
-  return FormatUrlForSecurityDisplayInternal(url, languages, false);
+base::string16 FormatUrlForSecurityDisplay(const GURL& url) {
+  return FormatUrlForSecurityDisplayInternal(url, false);
 }
 
-base::string16 FormatUrlForSecurityDisplayOmitScheme(
-    const GURL& url,
-    const std::string& languages) {
-  return FormatUrlForSecurityDisplayInternal(url, languages, true);
+base::string16 FormatUrlForSecurityDisplayOmitScheme(const GURL& url) {
+  return FormatUrlForSecurityDisplayInternal(url, true);
 }
 
 }  // namespace url_formatter