Move net::FormatUrl and friends outside of //net and into //components

components/url_formatter/url_formatter_unittest.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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 "net/base/net_util.h"
+#include "components/url_formatter/url_formatter.h"
 
 #include <string.h>
 
 #include <vector>
 
-#include "base/format_macros.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
-using base::ASCIIToUTF16;
-using base::WideToUTF16;
 
-namespace net {
+namespace url_formatter {
 
 namespace {
 
+using base::WideToUTF16;
+using base::ASCIIToUTF16;
+
 const size_t kNpos = base::string16::npos;
 
 const char* const kLanguages[] = {
   "",      "en",    "zh-CN",    "ja",    "ko",
   "he",    "ar",    "ru",       "el",    "fr",
   "de",    "pt",    "sv",       "th",    "hi",
   "de,en", "el,en", "zh-TW,en", "ko,ja", "he,ru,en",
   "zh,ru,en"
 };
 
@@ skipping 331 matching lines @@
 struct AdjustOffsetCase {
   size_t input_offset;
   size_t output_offset;
 };
 
 struct UrlTestData {
   const char* const description;
   const char* const input;
   const char* const languages;
   FormatUrlTypes format_types;
-  UnescapeRule::Type escape_rules;
+  net::UnescapeRule::Type escape_rules;
   const wchar_t* output;  // Use |wchar_t| to handle Unicode constants easily.
   size_t prefix_len;
 };
 
 // A helper for IDN*{Fast,Slow}.
 // Append "::<language list>" to |expected| and |actual| to make it
 // easy to tell which sub-case fails without debugging.
 void AppendLanguagesToOutputs(const char* languages,
                               base::string16* expected,
                               base::string16* actual) {
   base::string16 to_append = ASCIIToUTF16("::") + ASCIIToUTF16(languages);
   expected->append(to_append);
   actual->append(to_append);
 }
 
 // A pair of helpers for the FormatUrlWithOffsets() test.
 void VerboseExpect(size_t expected,
                    size_t actual,
                    const std::string& original_url,
                    size_t position,
                    const base::string16& formatted_url) {
   EXPECT_EQ(expected, actual) << "Original URL: " << original_url
       << " (at char " << position << ")\nFormatted URL: " << formatted_url;
 }
 
 void CheckAdjustedOffsets(const std::string& url_string,
                           const std::string& languages,
                           FormatUrlTypes format_types,
-                          UnescapeRule::Type unescape_rules,
+                          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, languages,
       format_types, unescape_rules, NULL, NULL, &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);
 }
 
-}  // anonymous namespace
-
-TEST(NetUtilTest, IDNToUnicodeFast) {
+TEST(UrlFormatterTest, IDNToUnicodeFast) {
   for (size_t i = 0; i < arraysize(idn_cases); i++) {
     for (size_t j = 0; j < arraysize(kLanguages); j++) {
       // ja || zh-TW,en || ko,ja -> IDNToUnicodeSlow
       if (j == 3 || j == 17 || j == 18)
         continue;
       base::string16 output(IDNToUnicode(idn_cases[i].input, kLanguages[j]));
       base::string16 expected(idn_cases[i].unicode_allowed[j] ?
           WideToUTF16(idn_cases[i].unicode_output) :
           ASCIIToUTF16(idn_cases[i].input));
       AppendLanguagesToOutputs(kLanguages[j], &expected, &output);
       EXPECT_EQ(expected, output) << "input: \"" << idn_cases[i].input
                                   << "\", languages: \"" << kLanguages[j]
                                   << "\"";
     }
   }
 }
 
-TEST(NetUtilTest, IDNToUnicodeSlow) {
+TEST(UrlFormatterTest, IDNToUnicodeSlow) {
   for (size_t i = 0; i < arraysize(idn_cases); i++) {
     for (size_t j = 0; j < arraysize(kLanguages); j++) {
       // !(ja || zh-TW,en || ko,ja) -> IDNToUnicodeFast
       if (!(j == 3 || j == 17 || j == 18))
         continue;
       base::string16 output(IDNToUnicode(idn_cases[i].input, kLanguages[j]));
       base::string16 expected(idn_cases[i].unicode_allowed[j] ?
           WideToUTF16(idn_cases[i].unicode_output) :
           ASCIIToUTF16(idn_cases[i].input));
       AppendLanguagesToOutputs(kLanguages[j], &expected, &output);
       EXPECT_EQ(expected, output) << "input: \"" << idn_cases[i].input
                                   << "\", languages: \"" << kLanguages[j]
                                   << "\"";
     }
   }
 }
 
 // ulocdata_getExemplarSet may fail with some locales (currently bn, gu, and
 // te), which was causing a crash (See http://crbug.com/510551).  This may be an
 // icu bug, but regardless, that should not cause a crash.
-TEST(NetUtilTest, IDNToUnicodeNeverCrashes) {
+TEST(UrlFormatterTest, IDNToUnicodeNeverCrashes) {
   for (char c1 = 'a'; c1 <= 'z'; c1++) {
     for (char c2 = 'a'; c2 <= 'z'; c2++) {
       std::string lang = base::StringPrintf("%c%c", c1, c2);
       base::string16 output(IDNToUnicode("xn--74h", lang));
     }
   }
 }
 
-TEST(NetUtilTest, StripWWW) {
-  EXPECT_EQ(base::string16(), StripWWW(base::string16()));
-  EXPECT_EQ(base::string16(), StripWWW(ASCIIToUTF16("www.")));
-  EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("www.blah")));
-  EXPECT_EQ(ASCIIToUTF16("blah"), StripWWW(ASCIIToUTF16("blah")));
-}
-
-// This is currently a windows specific function.
-#if defined(OS_WIN)
-namespace {
-
-struct GetDirectoryListingEntryCase {
-  const wchar_t* name;
-  const char* const raw_bytes;
-  bool is_dir;
-  int64_t filesize;
-  base::Time time;
-  const char* const expected;
-};
-
-}  // namespace
-
-TEST(NetUtilTest, GetDirectoryListingEntry) {
-  const GetDirectoryListingEntryCase test_cases[] = {
-    {L"Foo",
-     "",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"Foo\",\"Foo\",0,\"9.8 kB\",\"\");</script>\n"},
-    {L"quo\"tes",
-     "",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"quo\\\"tes\",\"quo%22tes\",0,\"9.8 kB\",\"\");</script>"
-         "\n"},
-    {L"quo\"tes",
-     "quo\"tes",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"quo\\\"tes\",\"quo%22tes\",0,\"9.8 kB\",\"\");</script>"
-         "\n"},
-    // U+D55C0 U+AE00. raw_bytes is empty (either a local file with
-    // UTF-8/UTF-16 encoding or a remote file on an ftp server using UTF-8
-    {L"\xD55C\xAE00.txt",
-     "",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"\xED\x95\x9C\xEA\xB8\x80.txt\","
-         "\"%ED%95%9C%EA%B8%80.txt\",0,\"9.8 kB\",\"\");</script>\n"},
-    // U+D55C0 U+AE00. raw_bytes is the corresponding EUC-KR sequence:
-    // a local or remote file in EUC-KR.
-    {L"\xD55C\xAE00.txt",
-     "\xC7\xD1\xB1\xDB.txt",
-     false,
-     10000,
-     base::Time(),
-     "<script>addRow(\"\xED\x95\x9C\xEA\xB8\x80.txt\",\"%C7%D1%B1%DB.txt\""
-         ",0,\"9.8 kB\",\"\");</script>\n"},
-  };
-
-  for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    const std::string results = GetDirectoryListingEntry(
-        WideToUTF16(test_cases[i].name),
-        test_cases[i].raw_bytes,
-        test_cases[i].is_dir,
-        test_cases[i].filesize,
-        test_cases[i].time);
-    EXPECT_EQ(test_cases[i].expected, results);
-  }
-}
-
-#endif
-
-TEST(NetUtilTest, FormatUrl) {
+TEST(UrlFormatterTest, FormatUrl) {
   FormatUrlTypes default_format_type = kFormatUrlOmitUsernamePassword;
   const UrlTestData tests[] = {
-    {"Empty URL", "", "", default_format_type, UnescapeRule::NORMAL, L"", 0},
+      {"Empty URL", "", "", default_format_type, net::UnescapeRule::NORMAL, L"",
+       0},
 
-    {"Simple URL",
-     "http://www.google.com/", "", default_format_type, UnescapeRule::NORMAL,
-     L"http://www.google.com/", 7},
+      {"Simple URL", "http://www.google.com/", "", default_format_type,
+       net::UnescapeRule::NORMAL, L"http://www.google.com/", 7},
 
-    {"With a port number and a reference",
-     "http://www.google.com:8080/#\xE3\x82\xB0", "", default_format_type,
-     UnescapeRule::NORMAL,
-     L"http://www.google.com:8080/#\x30B0", 7},
+      {"With a port number and a reference",
+       "http://www.google.com:8080/#\xE3\x82\xB0", "", default_format_type,
+       net::UnescapeRule::NORMAL, L"http://www.google.com:8080/#\x30B0", 7},
 
-    // -------- IDN tests --------
-    {"Japanese IDN with ja",
-     "http://xn--l8jvb1ey91xtjb.jp", "ja", default_format_type,
-     UnescapeRule::NORMAL, L"http://\x671d\x65e5\x3042\x3055\x3072.jp/", 7},
+      // -------- IDN tests --------
+      {"Japanese IDN with ja", "http://xn--l8jvb1ey91xtjb.jp", "ja",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"http://\x671d\x65e5\x3042\x3055\x3072.jp/", 7},
 
-    {"Japanese IDN with en",
-     "http://xn--l8jvb1ey91xtjb.jp", "en", default_format_type,
-     UnescapeRule::NORMAL, L"http://xn--l8jvb1ey91xtjb.jp/", 7},
+      {"Japanese IDN with en", "http://xn--l8jvb1ey91xtjb.jp", "en",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"http://xn--l8jvb1ey91xtjb.jp/", 7},
 
-    {"Japanese IDN without any languages",
-     "http://xn--l8jvb1ey91xtjb.jp", "", default_format_type,
-     UnescapeRule::NORMAL,
-     // Single script is safe for empty languages.
-     L"http://\x671d\x65e5\x3042\x3055\x3072.jp/", 7},
+      {"Japanese IDN without any languages", "http://xn--l8jvb1ey91xtjb.jp", "",
+       default_format_type, net::UnescapeRule::NORMAL,
+       // Single script is safe for empty languages.
+       L"http://\x671d\x65e5\x3042\x3055\x3072.jp/", 7},
 
-    {"mailto: with Japanese IDN",
-     "mailto:foo@xn--l8jvb1ey91xtjb.jp", "ja", default_format_type,
-     UnescapeRule::NORMAL,
-     // GURL doesn't assume an email address's domain part as a host name.
-     L"mailto:foo@xn--l8jvb1ey91xtjb.jp", 7},
+      {"mailto: with Japanese IDN", "mailto:foo@xn--l8jvb1ey91xtjb.jp", "ja",
+       default_format_type, net::UnescapeRule::NORMAL,
+       // GURL doesn't assume an email address's domain part as a host name.
+       L"mailto:foo@xn--l8jvb1ey91xtjb.jp", 7},
 
-    {"file: with Japanese IDN",
-     "file://xn--l8jvb1ey91xtjb.jp/config.sys", "ja", default_format_type,
-     UnescapeRule::NORMAL,
-     L"file://\x671d\x65e5\x3042\x3055\x3072.jp/config.sys", 7},
+      {"file: with Japanese IDN", "file://xn--l8jvb1ey91xtjb.jp/config.sys",
+       "ja", default_format_type, net::UnescapeRule::NORMAL,
+       L"file://\x671d\x65e5\x3042\x3055\x3072.jp/config.sys", 7},
 
-    {"ftp: with Japanese IDN",
-     "ftp://xn--l8jvb1ey91xtjb.jp/config.sys", "ja", default_format_type,
-     UnescapeRule::NORMAL,
-     L"ftp://\x671d\x65e5\x3042\x3055\x3072.jp/config.sys", 6},
+      {"ftp: with Japanese IDN", "ftp://xn--l8jvb1ey91xtjb.jp/config.sys", "ja",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"ftp://\x671d\x65e5\x3042\x3055\x3072.jp/config.sys", 6},
 
-    // -------- omit_username_password flag tests --------
-    {"With username and password, omit_username_password=false",
-     "http://user:passwd@example.com/foo", "",
-     kFormatUrlOmitNothing, UnescapeRule::NORMAL,
-     L"http://user:passwd@example.com/foo", 19},
+      // -------- omit_username_password flag tests --------
+      {"With username and password, omit_username_password=false",
+       "http://user:passwd@example.com/foo", "", kFormatUrlOmitNothing,
+       net::UnescapeRule::NORMAL, L"http://user:passwd@example.com/foo", 19},
 
-    {"With username and password, omit_username_password=true",
-     "http://user:passwd@example.com/foo", "", default_format_type,
-     UnescapeRule::NORMAL, L"http://example.com/foo", 7},
+      {"With username and password, omit_username_password=true",
+       "http://user:passwd@example.com/foo", "", default_format_type,
+       net::UnescapeRule::NORMAL, L"http://example.com/foo", 7},
 
-    {"With username and no password",
-     "http://user@example.com/foo", "", default_format_type,
-     UnescapeRule::NORMAL, L"http://example.com/foo", 7},
+      {"With username and no password", "http://user@example.com/foo", "",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"http://example.com/foo", 7},
 
-    {"Just '@' without username and password",
-     "http://@example.com/foo", "", default_format_type, UnescapeRule::NORMAL,
-     L"http://example.com/foo", 7},
+      {"Just '@' without username and password", "http://@example.com/foo", "",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"http://example.com/foo", 7},
 
-    // GURL doesn't think local-part of an email address is username for URL.
-    {"mailto:, omit_username_password=true",
-     "mailto:foo@example.com", "", default_format_type, UnescapeRule::NORMAL,
-     L"mailto:foo@example.com", 7},
+      // GURL doesn't think local-part of an email address is username for URL.
+      {"mailto:, omit_username_password=true", "mailto:foo@example.com", "",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"mailto:foo@example.com", 7},
 
-    // -------- unescape flag tests --------
-    {"Do not unescape",
-     "http://%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB.jp/"
-     "%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
-     "?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB", "en", default_format_type,
-     UnescapeRule::NONE,
-     // GURL parses %-encoded hostnames into Punycode.
-     L"http://xn--qcka1pmc.jp/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
-     L"?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB", 7},
+      // -------- unescape flag tests --------
+      {"Do not unescape",
+       "http://%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB.jp/"
+       "%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
+       "?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB",
+       "en", default_format_type, net::UnescapeRule::NONE,
+       // GURL parses %-encoded hostnames into Punycode.
+       L"http://xn--qcka1pmc.jp/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
+       L"?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB",
+       7},
 
-    {"Unescape normally",
-     "http://%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB.jp/"
-     "%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
-     "?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB", "en", default_format_type,
-     UnescapeRule::NORMAL,
-     L"http://xn--qcka1pmc.jp/\x30B0\x30FC\x30B0\x30EB"
-     L"?q=\x30B0\x30FC\x30B0\x30EB", 7},
+      {"Unescape normally",
+       "http://%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB.jp/"
+       "%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB"
+       "?q=%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB",
+       "en", default_format_type, net::UnescapeRule::NORMAL,
+       L"http://xn--qcka1pmc.jp/\x30B0\x30FC\x30B0\x30EB"
+       L"?q=\x30B0\x30FC\x30B0\x30EB",
+       7},
 
-    {"Unescape normally with BiDi control character",
-     "http://example.com/%E2%80%AEabc?q=%E2%80%8Fxy", "en", default_format_type,
-     UnescapeRule::NORMAL, L"http://example.com/%E2%80%AEabc?q=%E2%80%8Fxy", 7},
+      {"Unescape normally with BiDi control character",
+       "http://example.com/%E2%80%AEabc?q=%E2%80%8Fxy", "en",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"http://example.com/%E2%80%AEabc?q=%E2%80%8Fxy", 7},
 
-    {"Unescape normally including unescape spaces",
-     "http://www.google.com/search?q=Hello%20World", "en", default_format_type,
-     UnescapeRule::SPACES, L"http://www.google.com/search?q=Hello World", 7},
+      {"Unescape normally including unescape spaces",
+       "http://www.google.com/search?q=Hello%20World", "en",
+       default_format_type, net::UnescapeRule::SPACES,
+       L"http://www.google.com/search?q=Hello World", 7},
 
-    /*
-    {"unescape=true with some special characters",
-    "http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", "",
-    kFormatUrlOmitNothing, UnescapeRule::NORMAL,
-    L"http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", 25},
-    */
-    // Disabled: the resultant URL becomes "...user%253A:%2540passwd...".
+      /*
+      {"unescape=true with some special characters",
+      "http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", "",
+      kFormatUrlOmitNothing, net::UnescapeRule::NORMAL,
+      L"http://user%3A:%40passwd@example.com/foo%3Fbar?q=b%26z", 25},
+      */
+      // Disabled: the resultant URL becomes "...user%253A:%2540passwd...".
 
-    // -------- omit http: --------
-    {"omit http with user name",
-     "http://user@example.com/foo", "", kFormatUrlOmitAll,
-     UnescapeRule::NORMAL, L"example.com/foo", 0},
+      // -------- omit http: --------
+      {"omit http with user name", "http://user@example.com/foo", "",
+       kFormatUrlOmitAll, net::UnescapeRule::NORMAL, L"example.com/foo", 0},
 
-    {"omit http",
-     "http://www.google.com/", "en", kFormatUrlOmitHTTP,
-     UnescapeRule::NORMAL, L"www.google.com/",
-     0},
+      {"omit http", "http://www.google.com/", "en", kFormatUrlOmitHTTP,
+       net::UnescapeRule::NORMAL, L"www.google.com/", 0},
 
-    {"omit http with https",
-     "https://www.google.com/", "en", kFormatUrlOmitHTTP,
-     UnescapeRule::NORMAL, L"https://www.google.com/",
-     8},
+      {"omit http with https", "https://www.google.com/", "en",
+       kFormatUrlOmitHTTP, net::UnescapeRule::NORMAL,
+       L"https://www.google.com/", 8},
 
-    {"omit http starts with ftp.",
-     "http://ftp.google.com/", "en", kFormatUrlOmitHTTP,
-     UnescapeRule::NORMAL, L"http://ftp.google.com/",
-     7},
+      {"omit http starts with ftp.", "http://ftp.google.com/", "en",
+       kFormatUrlOmitHTTP, net::UnescapeRule::NORMAL, L"http://ftp.google.com/",
+       7},
 
-    // -------- omit trailing slash on bare hostname --------
-    {"omit slash when it's the entire path",
-     "http://www.google.com/", "en",
-     kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
-     L"http://www.google.com", 7},
-    {"omit slash when there's a ref",
-     "http://www.google.com/#ref", "en",
-     kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
-     L"http://www.google.com/#ref", 7},
-    {"omit slash when there's a query",
-     "http://www.google.com/?", "en",
-     kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
-     L"http://www.google.com/?", 7},
-    {"omit slash when it's not the entire path",
-     "http://www.google.com/foo", "en",
-     kFormatUrlOmitTrailingSlashOnBareHostname, UnescapeRule::NORMAL,
-     L"http://www.google.com/foo", 7},
-    {"omit slash for nonstandard URLs",
-     "data:/", "en", kFormatUrlOmitTrailingSlashOnBareHostname,
-     UnescapeRule::NORMAL, L"data:/", 5},
-    {"omit slash for file URLs",
-     "file:///", "en", kFormatUrlOmitTrailingSlashOnBareHostname,
-     UnescapeRule::NORMAL, L"file:///", 7},
+      // -------- omit trailing slash on bare hostname --------
+      {"omit slash when it's the entire path", "http://www.google.com/", "en",
+       kFormatUrlOmitTrailingSlashOnBareHostname, net::UnescapeRule::NORMAL,
+       L"http://www.google.com", 7},
+      {"omit slash when there's a ref", "http://www.google.com/#ref", "en",
+       kFormatUrlOmitTrailingSlashOnBareHostname, net::UnescapeRule::NORMAL,
+       L"http://www.google.com/#ref", 7},
+      {"omit slash when there's a query", "http://www.google.com/?", "en",
+       kFormatUrlOmitTrailingSlashOnBareHostname, net::UnescapeRule::NORMAL,
+       L"http://www.google.com/?", 7},
+      {"omit slash when it's not the entire path", "http://www.google.com/foo",
+       "en", kFormatUrlOmitTrailingSlashOnBareHostname,
+       net::UnescapeRule::NORMAL, L"http://www.google.com/foo", 7},
+      {"omit slash for nonstandard URLs", "data:/", "en",
+       kFormatUrlOmitTrailingSlashOnBareHostname, net::UnescapeRule::NORMAL,
+       L"data:/", 5},
+      {"omit slash for file URLs", "file:///", "en",
+       kFormatUrlOmitTrailingSlashOnBareHostname, net::UnescapeRule::NORMAL,
+       L"file:///", 7},
 
-    // -------- view-source: --------
-    {"view-source",
-     "view-source:http://xn--qcka1pmc.jp/", "ja", default_format_type,
-     UnescapeRule::NORMAL, L"view-source:http://\x30B0\x30FC\x30B0\x30EB.jp/",
-     19},
+      // -------- view-source: --------
+      {"view-source", "view-source:http://xn--qcka1pmc.jp/", "ja",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"view-source:http://\x30B0\x30FC\x30B0\x30EB.jp/", 19},
 
-    {"view-source of view-source",
-     "view-source:view-source:http://xn--qcka1pmc.jp/", "ja",
-     default_format_type, UnescapeRule::NORMAL,
-     L"view-source:view-source:http://xn--qcka1pmc.jp/", 12},
+      {"view-source of view-source",
+       "view-source:view-source:http://xn--qcka1pmc.jp/", "ja",
+       default_format_type, net::UnescapeRule::NORMAL,
+       L"view-source:view-source:http://xn--qcka1pmc.jp/", 12},
 
-    // view-source should omit http and trailing slash where non-view-source
-    // would.
-    {"view-source omit http",
-     "view-source:http://a.b/c", "en", kFormatUrlOmitAll,
-     UnescapeRule::NORMAL, L"view-source:a.b/c",
-     12},
-    {"view-source omit http starts with ftp.",
-     "view-source:http://ftp.b/c", "en", kFormatUrlOmitAll,
-     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/", "en", kFormatUrlOmitAll,
-     UnescapeRule::NORMAL, L"view-source:a.b",
-     12},
+      // view-source should omit http and trailing slash where non-view-source
+      // would.
+      {"view-source omit http", "view-source:http://a.b/c", "en",
+       kFormatUrlOmitAll, net::UnescapeRule::NORMAL, L"view-source:a.b/c", 12},
+      {"view-source omit http starts with ftp.", "view-source:http://ftp.b/c",
+       "en", 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/", "en", 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), tests[i].languages, tests[i].format_types,
         tests[i].escape_rules, NULL, &prefix_len, NULL);
     EXPECT_EQ(WideToUTF16(tests[i].output), formatted) << tests[i].description;
     EXPECT_EQ(tests[i].prefix_len, prefix_len) << tests[i].description;
   }
 }
 
-TEST(NetUtilTest, FormatUrlParsed) {
+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"),
-      "ja", kFormatUrlOmitNothing, UnescapeRule::NONE, &parsed, NULL,
-      NULL);
+  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"),
+                "ja", kFormatUrlOmitNothing, net::UnescapeRule::NONE, &parsed,
+                NULL, NULL);
   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, UnescapeRule::NORMAL, &parsed, NULL,
-      NULL);
+  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);
   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, UnescapeRule::NORMAL, &parsed,
-      NULL, NULL);
+  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);
   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,
-                UnescapeRule::NORMAL,
-                &parsed,
-                NULL,
-                NULL);
+                std::string(), kFormatUrlOmitUsernamePassword,
+                net::UnescapeRule::NORMAL, &parsed, NULL, NULL);
   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,
-                        UnescapeRule::NORMAL,
-                        &parsed,
-                        NULL,
-                        NULL);
+  formatted = FormatUrl(GURL("http://host:8000/a?b=c#d"), std::string(),
+                        kFormatUrlOmitHTTP, net::UnescapeRule::NORMAL, &parsed,
+                        NULL, NULL);
   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(),
-                        kFormatUrlOmitHTTP,
-                        UnescapeRule::NORMAL,
-                        &parsed,
-                        NULL,
-                        NULL);
+  formatted = FormatUrl(GURL("http://ftp.host:8000/a?b=c#d"), std::string(),
+                        kFormatUrlOmitHTTP, net::UnescapeRule::NORMAL, &parsed,
+                        NULL, NULL);
   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,
-                        UnescapeRule::NORMAL,
-                        &parsed,
-                        NULL,
-                        NULL);
+  formatted = FormatUrl(GURL("http://f/"), std::string(), kFormatUrlOmitHTTP,
+                        net::UnescapeRule::NORMAL, &parsed, NULL, NULL);
   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(NetUtilTest, FormatUrlRoundTripPathASCII) {
+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,
-                                         UnescapeRule::NORMAL,
-                                         NULL,
-                                         &prefix_len,
-                                         NULL);
+    base::string16 formatted =
+        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
     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(NetUtilTest, FormatUrlRoundTripPathEscaped) {
+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,
-                                         UnescapeRule::NORMAL,
-                                         NULL,
-                                         &prefix_len,
-                                         NULL);
+    base::string16 formatted =
+        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
     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(NetUtilTest, FormatUrlRoundTripQueryASCII) {
+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,
-                                         UnescapeRule::NORMAL,
-                                         NULL,
-                                         &prefix_len,
-                                         NULL);
+    base::string16 formatted =
+        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
     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(NetUtilTest, FormatUrlRoundTripQueryEscaped) {
+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,
-                                         UnescapeRule::NORMAL,
-                                         NULL,
-                                         &prefix_len,
-                                         NULL);
+    base::string16 formatted =
+        FormatUrl(url, std::string(), kFormatUrlOmitUsernamePassword,
+                  net::UnescapeRule::NORMAL, NULL, &prefix_len, NULL);
 
     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(NetUtilTest, FormatUrlWithOffsets) {
+TEST(UrlFormatterTest, FormatUrlWithOffsets) {
   CheckAdjustedOffsets(std::string(), "en", kFormatUrlOmitNothing,
-                       UnescapeRule::NORMAL, NULL);
+                       net::UnescapeRule::NORMAL, NULL);
 
   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/", "en",
-                       kFormatUrlOmitNothing, UnescapeRule::NORMAL,
+                       kFormatUrlOmitNothing, net::UnescapeRule::NORMAL,
                        basic_offsets);
 
   const size_t omit_auth_offsets_1[] = {
     0, 1, 2, 3, 4, 5, 6, 7, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 7,
     8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21
   };
   CheckAdjustedOffsets("http://foo:bar@www.google.com/", "en",
-                       kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
-                       omit_auth_offsets_1);
+                       kFormatUrlOmitUsernamePassword,
+                       net::UnescapeRule::NORMAL, omit_auth_offsets_1);
 
   const size_t omit_auth_offsets_2[] = {
     0, 1, 2, 3, 4, 5, 6, 7, kNpos, kNpos, kNpos, 7, 8, 9, 10, 11, 12, 13, 14,
     15, 16, 17, 18, 19, 20, 21
   };
   CheckAdjustedOffsets("http://foo@www.google.com/", "en",
-                       kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
-                       omit_auth_offsets_2);
+                       kFormatUrlOmitUsernamePassword,
+                       net::UnescapeRule::NORMAL, omit_auth_offsets_2);
 
   const size_t dont_omit_auth_offsets[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, kNpos, 11, 12, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
     30, 31
   };
   // Unescape to "http://foo\x30B0:\x30B0bar@www.google.com".
   CheckAdjustedOffsets("http://foo%E3%82%B0:%E3%82%B0bar@www.google.com/", "en",
-                       kFormatUrlOmitNothing, UnescapeRule::NORMAL,
+                       kFormatUrlOmitNothing, net::UnescapeRule::NORMAL,
                        dont_omit_auth_offsets);
 
   const size_t view_source_offsets[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, kNpos,
     kNpos, kNpos, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33
   };
   CheckAdjustedOffsets("view-source:http://foo@www.google.com/", "en",
-                       kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL,
-                       view_source_offsets);
+                       kFormatUrlOmitUsernamePassword,
+                       net::UnescapeRule::NORMAL, view_source_offsets);
 
   const size_t idn_hostname_offsets_1[] = {
     0, 1, 2, 3, 4, 5, 6, 7, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 12,
     13, 14, 15, 16, 17, 18, 19
   };
   // Convert punycode to "http://\x671d\x65e5\x3042\x3055\x3072.jp/foo/".
   CheckAdjustedOffsets("http://xn--l8jvb1ey91xtjb.jp/foo/", "ja",
-                       kFormatUrlOmitNothing, UnescapeRule::NORMAL,
+                       kFormatUrlOmitNothing, net::UnescapeRule::NORMAL,
                        idn_hostname_offsets_1);
 
   const size_t idn_hostname_offsets_2[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 14, 15, kNpos, kNpos, kNpos,
     kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, 19, 20, 21, 22, 23, 24
   };
   // Convert punycode to
   // "http://test.\x89c6\x9891.\x5317\x4eac\x5927\x5b78.test/".
   CheckAdjustedOffsets("http://test.xn--cy2a840a.xn--1lq90ic7f1rc.test/",
-                       "zh-CN", kFormatUrlOmitNothing, UnescapeRule::NORMAL,
-                       idn_hostname_offsets_2);
+                       "zh-CN", kFormatUrlOmitNothing,
+                       net::UnescapeRule::NORMAL, idn_hostname_offsets_2);
 
   const size_t unescape_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, kNpos, kNpos, 26, 27, 28, 29, 30, kNpos, kNpos, kNpos,
     kNpos, kNpos, kNpos, kNpos, kNpos, 31, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, kNpos, kNpos, 32, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos,
     kNpos, 33, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos
   };
   // Unescape to "http://www.google.com/foo bar/\x30B0\x30FC\x30B0\x30EB".
   CheckAdjustedOffsets(
       "http://www.google.com/foo%20bar/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB",
-      "en", kFormatUrlOmitNothing, UnescapeRule::SPACES, unescape_offsets);
+      "en", kFormatUrlOmitNothing, net::UnescapeRule::SPACES, unescape_offsets);
 
   const size_t ref_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, 26, 27, 28, 29, 30, 31, kNpos, kNpos, 32, kNpos, kNpos,
     33
   };
   // Unescape to "http://www.google.com/foo.html#\x30B0\x30B0z".
   CheckAdjustedOffsets(
       "http://www.google.com/foo.html#\xE3\x82\xB0\xE3\x82\xB0z", "en",
-      kFormatUrlOmitNothing, UnescapeRule::NORMAL, ref_offsets);
+      kFormatUrlOmitNothing, net::UnescapeRule::NORMAL, ref_offsets);
 
   const size_t omit_http_offsets[] = {
     0, kNpos, kNpos, kNpos, kNpos, kNpos, kNpos, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
     10, 11, 12, 13, 14
   };
   CheckAdjustedOffsets("http://www.google.com/", "en", kFormatUrlOmitHTTP,
-                       UnescapeRule::NORMAL, omit_http_offsets);
+                       net::UnescapeRule::NORMAL, omit_http_offsets);
 
   const size_t omit_http_start_with_ftp_offsets[] = {
     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21
   };
   CheckAdjustedOffsets("http://ftp.google.com/", "en", kFormatUrlOmitHTTP,
-                       UnescapeRule::NORMAL, omit_http_start_with_ftp_offsets);
+                       net::UnescapeRule::NORMAL,
+                       omit_http_start_with_ftp_offsets);
 
   const size_t omit_all_offsets[] = {
     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/", "en", kFormatUrlOmitAll,
-                       UnescapeRule::NORMAL, omit_all_offsets);
+                       net::UnescapeRule::NORMAL, omit_all_offsets);
 }
 
-}  // namespace net
+}  // namespace
+
+}  // namespace url_formatter