net: move GetIdentifyFromURL function into url_util.h

net/base/net_util_unittest.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 "net/base/net_util.h"
 
 #include <ostream>
 
 #include "base/format_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
 #include "net/base/address_list.h"
 #include "net/base/ip_endpoint.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 #if !defined(OS_NACL) && !defined(OS_WIN)
 #include <net/if.h>
 #include <netinet/in.h>
 #if defined(OS_MACOSX)
 #include <ifaddrs.h>
 #if !defined(OS_IOS)
 #include <netinet/in_var.h>
 #endif  // !OS_IOS
 #endif  // OS_MACOSX
 #endif  // !OS_NACL && !OS_WIN
 
-#if defined(OS_WIN)
-#include <iphlpapi.h>
-#include <objbase.h>
-#include "base/win/windows_version.h"
-#endif  // OS_WIN
-
 #if !defined(OS_MACOSX) && !defined(OS_NACL) && !defined(OS_WIN)
 #include "net/base/address_tracker_linux.h"
 #endif  // !OS_MACOSX && !OS_NACL && !OS_WIN
 
-using base::ASCIIToUTF16;
-using base::WideToUTF16;
-
 namespace net {
 
 namespace {
 
 const unsigned char kLocalhostIPv4[] = {127, 0, 0, 1};
 const unsigned char kLocalhostIPv6[] =
     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 const uint16_t kLocalhostLookupPort = 80;
 
 bool HasEndpoint(const IPEndPoint& endpoint, const AddressList& addresses) {
@@ skipping 28 matching lines @@
       kLocalhostLookupPort);
 
   AddressList addresses;
   EXPECT_TRUE(ResolveLocalHostname(host, kLocalhostLookupPort, &addresses));
   EXPECT_EQ(1u, addresses.size());
   EXPECT_TRUE(HasEndpoint(localhost_ipv6, addresses));
 }
 
 }  // anonymous namespace
 
-TEST(NetUtilTest, GetIdentityFromURL) {
+TEST(NetUtilTest, CompliantHost) {
   struct {
-    const char* const input_url;
-    const char* const expected_username;
-    const char* const expected_password;
-  } tests[] = {
-    {
-      "http://username:password@google.com",
-      "username",
-      "password",
-    },
-    { // Test for http://crbug.com/19200
-      "http://username:p@ssword@google.com",
-      "username",
-      "p@ssword",
-    },
-    { // Special URL characters should be unescaped.
-      "http://username:p%3fa%26s%2fs%23@google.com",
-      "username",
-      "p?a&s/s#",
-    },
-    { // Username contains %20.
-      "http://use rname:password@google.com",
-      "use rname",
-      "password",
-    },
-    { // Keep %00 as is.
-      "http://use%00rname:password@google.com",
-      "use%00rname",
-      "password",
-    },
-    { // Use a '+' in the username.
-      "http://use+rname:password@google.com",
-      "use+rname",
-      "password",
-    },
-    { // Use a '&' in the password.
-      "http://username:p&ssword@google.com",
-      "username",
-      "p&ssword",
-    },
-  };
-  for (size_t i = 0; i < arraysize(tests); ++i) {
-    SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
-                                    tests[i].input_url));
-    GURL url(tests[i].input_url);
-
-    base::string16 username, password;
-    GetIdentityFromURL(url, &username, &password);
-
-    EXPECT_EQ(ASCIIToUTF16(tests[i].expected_username), username);
-    EXPECT_EQ(ASCIIToUTF16(tests[i].expected_password), password);
-  }
-}
-
-// Try extracting a username which was encoded with UTF8.
-TEST(NetUtilTest, GetIdentityFromURL_UTF8) {
-  GURL url(WideToUTF16(L"http://foo:\x4f60\x597d@blah.com"));
-
-  EXPECT_EQ("foo", url.username());
-  EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password());
-
-  // Extract the unescaped identity.
-  base::string16 username, password;
-  GetIdentityFromURL(url, &username, &password);
-
-  // Verify that it was decoded as UTF8.
-  EXPECT_EQ(ASCIIToUTF16("foo"), username);
-  EXPECT_EQ(WideToUTF16(L"\x4f60\x597d"), password);
-}
-
-TEST(NetUtilTest, CompliantHost) {
-  struct CompliantHostCase {
     const char* const host;
     bool expected_output;
-  };
-
-  const CompliantHostCase compliant_host_cases[] = {
+  } compliant_host_cases[] = {
       {"", false},
       {"a", true},
       {"-", false},
       {"_", false},
       {".", false},
       {"9", true},
       {"9a", true},
       {"9_", true},
       {"a.", true},
       {"a.a", true},
@@ skipping 273 matching lines @@
   EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
   EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(
       ResolveLocalHostname("foo.localhoste", kLocalhostLookupPort, &addresses));
 }
 
 TEST(NetUtilTest, GoogleHost) {
-  struct GoogleHostCase {
+  struct {
     GURL url;
     bool expected_output;
-  };
-
-  const GoogleHostCase google_host_cases[] = {
+  } google_host_cases[] = {
       {GURL("http://.google.com"), true},
       {GURL("http://.youtube.com"), true},
       {GURL("http://.gmail.com"), true},
       {GURL("http://.doubleclick.net"), true},
       {GURL("http://.gstatic.com"), true},
       {GURL("http://.googlevideo.com"), true},
       {GURL("http://.googleusercontent.com"), true},
       {GURL("http://.googlesyndication.com"), true},
       {GURL("http://.google-analytics.com"), true},
       {GURL("http://.googleadservices.com"), true},
@@ skipping 90 matching lines @@
 TEST_P(NetUtilNonUniqueNameTest, IsHostnameNonUnique) {
   const NonUniqueNameTestData& test_data = GetParam();
 
   EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname));
 }
 
 INSTANTIATE_TEST_CASE_P(, NetUtilNonUniqueNameTest,
                         testing::ValuesIn(kNonUniqueNameTestData));
 
 }  // namespace net