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

components/url_formatter/url_formatter_unittest.cc

 // Copyright 2015 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/url_formatter.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <vector>
@@ skipping 361 matching lines @@
                           FormatUrlTypes format_types,
                           net::UnescapeRule::Type unescape_rules,
                           const size_t* output_offsets) {
   GURL url(url_string);
   size_t url_length = url_string.length();
   std::vector<size_t> offsets;
   for (size_t i = 0; i <= url_length + 1; ++i)
     offsets.push_back(i);
   offsets.push_back(500000);  // Something larger than any input length.
   offsets.push_back(std::string::npos);
-  base::string16 formatted_url = FormatUrlWithOffsets(url, std::string(),
-      format_types, unescape_rules, NULL, NULL, &offsets);
+  base::string16 formatted_url = FormatUrlWithOffsets(url, format_types,
+      unescape_rules, nullptr, nullptr, &offsets);
   for (size_t i = 0; i < url_length; ++i)
     VerboseExpect(output_offsets[i], offsets[i], url_string, i, formatted_url);
   VerboseExpect(formatted_url.length(), offsets[url_length], url_string,
                 url_length, formatted_url);
   VerboseExpect(base::string16::npos, offsets[url_length + 1], url_string,
                 500000, formatted_url);
   VerboseExpect(base::string16::npos, offsets[url_length + 2], url_string,
                 std::string::npos, formatted_url);
 }
 
 TEST(UrlFormatterTest, IDNToUnicode) {
   for (size_t i = 0; i < arraysize(idn_cases); i++) {
-    base::string16 output(IDNToUnicode(idn_cases[i].input, std::string()));
+    base::string16 output(IDNToUnicode(idn_cases[i].input));
     base::string16 expected(idn_cases[i].unicode_allowed
                                 ? WideToUTF16(idn_cases[i].unicode_output)
                                 : ASCIIToUTF16(idn_cases[i].input));
     EXPECT_EQ(expected, output) << "input # " << i << ": \""
                                 << idn_cases[i].input << "\"";
   }
 }
 
 TEST(UrlFormatterTest, FormatUrl) {
   FormatUrlTypes default_format_type = kFormatUrlOmitUsernamePassword;
@@ skipping 139 matching lines @@
        kFormatUrlOmitAll, net::UnescapeRule::NORMAL,
        L"view-source:http://ftp.b/c", 19},
       {"view-source omit slash when it's the entire path",
        "view-source:http://a.b/", kFormatUrlOmitAll,
        net::UnescapeRule::NORMAL, L"view-source:a.b", 12},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     size_t prefix_len;
     base::string16 formatted = FormatUrl(
-        GURL(tests[i].input), std::string(), tests[i].format_types,
-        tests[i].escape_rules, NULL,  &prefix_len, NULL);
+        GURL(tests[i].input), tests[i].format_types, tests[i].escape_rules,
+        nullptr,  &prefix_len, nullptr);
     EXPECT_EQ(WideToUTF16(tests[i].output), formatted) << tests[i].description;
     EXPECT_EQ(tests[i].prefix_len, prefix_len) << tests[i].description;
   }
 }
 
 TEST(UrlFormatterTest, FormatUrlParsed) {
   // No unescape case.
   url::Parsed parsed;
   base::string16 formatted =
       FormatUrl(GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
                      "%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
-                std::string(), kFormatUrlOmitNothing, net::UnescapeRule::NONE,
-                &parsed, NULL, NULL);
+                kFormatUrlOmitNothing, net::UnescapeRule::NONE,
+                &parsed, nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(
       L"http://%E3%82%B0:%E3%83%BC@\x30B0\x30FC\x30B0\x30EB.jp:8080"
       L"/%E3%82%B0/?q=%E3%82%B0#\x30B0"), formatted);
   EXPECT_EQ(WideToUTF16(L"%E3%82%B0"),
       formatted.substr(parsed.username.begin, parsed.username.len));
   EXPECT_EQ(WideToUTF16(L"%E3%83%BC"),
       formatted.substr(parsed.password.begin, parsed.password.len));
   EXPECT_EQ(WideToUTF16(L"\x30B0\x30FC\x30B0\x30EB.jp"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8080"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/%E3%82%B0/"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"q=%E3%82%B0"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"\x30B0"),
       formatted.substr(parsed.ref.begin, parsed.ref.len));
 
   // Unescape case.
   formatted =
       FormatUrl(GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
                      "%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
-                "ja", kFormatUrlOmitNothing, net::UnescapeRule::NORMAL, &parsed,
-                NULL, NULL);
+                kFormatUrlOmitNothing, net::UnescapeRule::NORMAL, &parsed,
+                nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(L"http://\x30B0:\x30FC@\x30B0\x30FC\x30B0\x30EB.jp:8080"
       L"/\x30B0/?q=\x30B0#\x30B0"), formatted);
   EXPECT_EQ(WideToUTF16(L"\x30B0"),
       formatted.substr(parsed.username.begin, parsed.username.len));
   EXPECT_EQ(WideToUTF16(L"\x30FC"),
       formatted.substr(parsed.password.begin, parsed.password.len));
   EXPECT_EQ(WideToUTF16(L"\x30B0\x30FC\x30B0\x30EB.jp"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8080"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/\x30B0/"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"q=\x30B0"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"\x30B0"),
       formatted.substr(parsed.ref.begin, parsed.ref.len));
 
   // Omit_username_password + unescape case.
   formatted =
       FormatUrl(GURL("http://\xE3\x82\xB0:\xE3\x83\xBC@xn--qcka1pmc.jp:8080/"
                      "%E3%82%B0/?q=%E3%82%B0#\xE3\x82\xB0"),
-                "ja", kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL,
-                &parsed, NULL, NULL);
+                kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL,
+                &parsed, nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(L"http://\x30B0\x30FC\x30B0\x30EB.jp:8080"
       L"/\x30B0/?q=\x30B0#\x30B0"), formatted);
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"\x30B0\x30FC\x30B0\x30EB.jp"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8080"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/\x30B0/"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"q=\x30B0"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"\x30B0"),
       formatted.substr(parsed.ref.begin, parsed.ref.len));
 
   // View-source case.
   formatted =
       FormatUrl(GURL("view-source:http://user:passwd@host:81/path?query#ref"),
-                std::string(), kFormatUrlOmitUsernamePassword,
-                net::UnescapeRule::NORMAL, &parsed, NULL, NULL);
+                kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL,
+                &parsed, nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(L"view-source:http://host:81/path?query#ref"),
       formatted);
   EXPECT_EQ(WideToUTF16(L"view-source:http"),
       formatted.substr(parsed.scheme.begin, parsed.scheme.len));
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"host"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"81"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/path"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"query"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"ref"),
       formatted.substr(parsed.ref.begin, parsed.ref.len));
 
   // omit http case.
-  formatted = FormatUrl(GURL("http://host:8000/a?b=c#d"), std::string(),
-                        kFormatUrlOmitHTTP, net::UnescapeRule::NORMAL, &parsed,
-                        NULL, NULL);
+  formatted = FormatUrl(GURL("http://host:8000/a?b=c#d"), kFormatUrlOmitHTTP,
+                        net::UnescapeRule::NORMAL, &parsed, nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(L"host:8000/a?b=c#d"), formatted);
   EXPECT_FALSE(parsed.scheme.is_valid());
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"host"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8000"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/a"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"b=c"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"d"),
       formatted.substr(parsed.ref.begin, parsed.ref.len));
 
   // omit http starts with ftp case.
-  formatted = FormatUrl(GURL("http://ftp.host:8000/a?b=c#d"), std::string(),
+  formatted = FormatUrl(GURL("http://ftp.host:8000/a?b=c#d"),
                         kFormatUrlOmitHTTP, net::UnescapeRule::NORMAL, &parsed,
-                        NULL, NULL);
+                        nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(L"http://ftp.host:8000/a?b=c#d"), formatted);
   EXPECT_TRUE(parsed.scheme.is_valid());
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"http"),
       formatted.substr(parsed.scheme.begin, parsed.scheme.len));
   EXPECT_EQ(WideToUTF16(L"ftp.host"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8000"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/a"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"b=c"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"d"),
       formatted.substr(parsed.ref.begin, parsed.ref.len));
 
   // omit http starts with 'f' case.
-  formatted = FormatUrl(GURL("http://f/"), std::string(), kFormatUrlOmitHTTP,
-                        net::UnescapeRule::NORMAL, &parsed, NULL, NULL);
+  formatted = FormatUrl(GURL("http://f/"), kFormatUrlOmitHTTP,
+                        net::UnescapeRule::NORMAL, &parsed, nullptr, nullptr);
   EXPECT_EQ(WideToUTF16(L"f/"), formatted);
   EXPECT_FALSE(parsed.scheme.is_valid());
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_FALSE(parsed.port.is_valid());
   EXPECT_TRUE(parsed.path.is_valid());
   EXPECT_FALSE(parsed.query.is_valid());
   EXPECT_FALSE(parsed.ref.is_valid());
   EXPECT_EQ(WideToUTF16(L"f"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"/"),
       formatted.substr(parsed.path.begin, parsed.path.len));
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // results in the original GURL, for each ASCII character in the path.
 TEST(UrlFormatterTest, FormatUrlRoundTripPathASCII) {
   for (unsigned char test_char = 32; test_char < 128; ++test_char) {
     GURL url(std::string("http://www.google.com/") +
              static_cast<char>(test_char));
     size_t prefix_len;
     base::string16 formatted =
-        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
-                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
+        FormatUrl(url, kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, nullptr, &prefix_len, nullptr);
     EXPECT_EQ(url.spec(), GURL(formatted).spec());
   }
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // results in the original GURL, for each escaped ASCII character in the path.
 TEST(UrlFormatterTest, FormatUrlRoundTripPathEscaped) {
   for (unsigned char test_char = 32; test_char < 128; ++test_char) {
     std::string original_url("http://www.google.com/");
     original_url.push_back('%');
     original_url.append(base::HexEncode(&test_char, 1));
 
     GURL url(original_url);
     size_t prefix_len;
-    base::string16 formatted =
-        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
-                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
+    base::string16 formatted = FormatUrl(url, kFormatUrlOmitUsernamePassword,
+        net::UnescapeRule::NORMAL, nullptr, &prefix_len, nullptr);
     EXPECT_EQ(url.spec(), GURL(formatted).spec());
   }
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // results in the original GURL, for each ASCII character in the query.
 TEST(UrlFormatterTest, FormatUrlRoundTripQueryASCII) {
   for (unsigned char test_char = 32; test_char < 128; ++test_char) {
     GURL url(std::string("http://www.google.com/?") +
              static_cast<char>(test_char));
     size_t prefix_len;
     base::string16 formatted =
-        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
-                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
+        FormatUrl(url, kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, nullptr, &prefix_len, nullptr);
     EXPECT_EQ(url.spec(), GURL(formatted).spec());
   }
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // only results in a different GURL for certain characters.
 TEST(UrlFormatterTest, FormatUrlRoundTripQueryEscaped) {
   // A full list of characters which FormatURL should unescape and GURL should
   // not escape again, when they appear in a query string.
   const char kUnescapedCharacters[] =
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_~";
   for (unsigned char test_char = 0; test_char < 128; ++test_char) {
     std::string original_url("http://www.google.com/?");
     original_url.push_back('%');
     original_url.append(base::HexEncode(&test_char, 1));
 
     GURL url(original_url);
     size_t prefix_len;
     base::string16 formatted =
-        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
-                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
+        FormatUrl(url, kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, nullptr, &prefix_len, nullptr);
 
     if (test_char &&
         strchr(kUnescapedCharacters, static_cast<char>(test_char))) {
       EXPECT_NE(url.spec(), GURL(formatted).spec());
     } else {
       EXPECT_EQ(url.spec(), GURL(formatted).spec());
     }
   }
 }
 
 TEST(UrlFormatterTest, FormatUrlWithOffsets) {
   CheckAdjustedOffsets(std::string(),  kFormatUrlOmitNothing,
-                       net::UnescapeRule::NORMAL, NULL);
+                       net::UnescapeRule::NORMAL, nullptr);
 
   const size_t basic_offsets[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
     21, 22, 23, 24, 25
   };
   CheckAdjustedOffsets("http://www.google.com/foo/",
                        kFormatUrlOmitNothing, net::UnescapeRule::NORMAL,
                        basic_offsets);
 
   const size_t omit_auth_offsets_1[] = {
@@ skipping 93 matching lines @@
     0, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 0, kNpos, kNpos, kNpos, kNpos,
     0, 1, 2, 3, 4, 5, 6, 7
   };
   CheckAdjustedOffsets("http://user@foo.com/", kFormatUrlOmitAll,
                        net::UnescapeRule::NORMAL, omit_all_offsets);
 }
 
 }  // namespace
 
 }  // namespace url_formatter