Convert ARRAYSIZE_UNSAFE -> arraysize in net/.

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 <string.h>
 
 #include <ostream>
 
@@ skipping 100 matching lines @@
       "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_UNSAFE(tests); ++i) {
+  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);
   }
@@ skipping 41 matching lines @@
 TEST(NetUtilTest, GetSpecificHeader) {
   const HeaderCase tests[] = {
     {"content-type", "text/html; charset=utf-8"},
     {"CONTENT-LENGTH", "378557"},
     {"Date", "Mon, 13 Nov 2006 21:38:09 GMT"},
     {"Bad-Header", ""},
     {"", ""},
   };
 
   // Test first with google_headers.
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string result =
         GetSpecificHeader(google_headers, tests[i].header_name);
     EXPECT_EQ(result, tests[i].expected);
   }
 
   // Test again with empty headers.
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string result = GetSpecificHeader(std::string(), tests[i].header_name);
     EXPECT_EQ(result, std::string());
   }
 }
 
 TEST(NetUtilTest, CompliantHost) {
   struct CompliantHostCase {
     const char* host;
     bool expected_output;
   };
@@ skipping 16 matching lines @@
     {"a+9a", false},
     {"-a.a9", true},
     {"1-.a-b", true},
     {"1_.a-b", false},
     {"1-2.a_b", true},
     {"a.b.c.d.e", true},
     {"1.2.3.4.5", true},
     {"1.2.3.4.5.", true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(compliant_host_cases); ++i) {
+  for (size_t i = 0; i < arraysize(compliant_host_cases); ++i) {
     EXPECT_EQ(compliant_host_cases[i].expected_output,
               IsCanonicalizedHostCompliant(compliant_host_cases[i].host));
   }
 }
 
 TEST(NetUtilTest, ParseHostAndPort) {
   const struct {
     const char* input;
     bool success;
     const char* expected_host;
@@ skipping 29 matching lines @@
     {"usrname@host", false, "", -1},
     {"usrname:password@host", false, "", -1},
     {":password@host", false, "", -1},
     {":password@host:80", false, "", -1},
     {":password@host", false, "", -1},
     {"@host", false, "", -1},
     {"[", false, "", -1},
     {"[]", false, "", -1},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string host;
     int port;
     bool ok = ParseHostAndPort(tests[i].input, &host, &port);
 
     EXPECT_EQ(tests[i].success, ok);
 
     if (tests[i].success) {
       EXPECT_EQ(tests[i].expected_host, host);
       EXPECT_EQ(tests[i].expected_port, port);
     }
   }
 }
 
 TEST(NetUtilTest, GetHostAndPort) {
   const struct {
     GURL url;
     const char* expected_host_and_port;
   } tests[] = {
     { GURL("http://www.foo.com/x"), "www.foo.com:80"},
     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 
     // For IPv6 literals should always include the brackets.
     { GURL("http://[1::2]/x"), "[1::2]:80"},
     { GURL("http://[::a]:33/x"), "[::a]:33"},
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string host_and_port = GetHostAndPort(tests[i].url);
     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
   }
 }
 
 TEST(NetUtilTest, GetHostAndOptionalPort) {
   const struct {
     GURL url;
     const char* expected_host_and_port;
   } tests[] = {
     { GURL("http://www.foo.com/x"), "www.foo.com"},
     { GURL("http://www.foo.com:21/x"), "www.foo.com:21"},
 
     // For IPv6 literals should always include the brackets.
     { GURL("http://[1::2]/x"), "[1::2]"},
     { GURL("http://[::a]:33/x"), "[::a]:33"},
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string host_and_port = GetHostAndOptionalPort(tests[i].url);
     EXPECT_EQ(std::string(tests[i].expected_host_and_port), host_and_port);
   }
 }
 
 TEST(NetUtilTest, IPAddressToString) {
   uint8 addr1[4] = {0, 0, 0, 0};
   EXPECT_EQ("0.0.0.0", IPAddressToString(addr1, sizeof(addr1)));
 
   uint8 addr2[4] = {192, 168, 0, 1};
@@ skipping 19 matching lines @@
 TEST(NetUtilTest, NetAddressToString_IPv4) {
   const struct {
     uint8 addr[4];
     const char* result;
   } tests[] = {
     {{0, 0, 0, 0}, "0.0.0.0"},
     {{127, 0, 0, 1}, "127.0.0.1"},
     {{192, 168, 0, 1}, "192.168.0.1"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv4Address(tests[i].addr, 80, &storage);
     std::string result = NetAddressToString(storage.addr, storage.addr_len);
     EXPECT_EQ(std::string(tests[i].result), result);
   }
 }
 
 TEST(NetUtilTest, NetAddressToString_IPv6) {
   const struct {
     uint8 addr[16];
     const char* result;
   } tests[] = {
     {{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 0xFE, 0xDC, 0xBA,
       0x98, 0x76, 0x54, 0x32, 0x10},
      "fedc:ba98:7654:3210:fedc:ba98:7654:3210"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     SockaddrStorage storage;
     MakeIPv6Address(tests[i].addr, 80, &storage);
     EXPECT_EQ(std::string(tests[i].result),
         NetAddressToString(storage.addr, storage.addr_len));
   }
 }
 
 TEST(NetUtilTest, NetAddressToStringWithPort_IPv4) {
   uint8 addr[] = {127, 0, 0, 1};
   SockaddrStorage storage;
@@ skipping 55 matching lines @@
     },
     { // Try an FTP URL -- strip both the reference and the username/password.
       "ftp://user:pass@google.com:80/sup?yo#X#X",
       "ftp://google.com:80/sup?yo",
     },
     { // Try a nonstandard URL
       "foobar://user:pass@google.com:80/sup?yo#X#X",
       "foobar://user:pass@google.com:80/sup?yo",
     },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s", i,
                                     tests[i].input_url));
     GURL input_url(GURL(tests[i].input_url));
     GURL expected_url(GURL(tests[i].expected_simplified_url));
     EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url));
   }
 }
 
 TEST(NetUtilTest, SetExplicitlyAllowedPortsTest) {
   std::string invalid[] = { "1,2,a", "'1','2'", "1, 2, 3", "1 0,11,12" };
   std::string valid[] = { "", "1", "1,2", "1,2,3", "10,11,12,13" };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(invalid); ++i) {
+  for (size_t i = 0; i < arraysize(invalid); ++i) {
     SetExplicitlyAllowedPorts(invalid[i]);
     EXPECT_EQ(0, static_cast<int>(GetCountOfExplicitlyAllowedPorts()));
   }
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(valid); ++i) {
+  for (size_t i = 0; i < arraysize(valid); ++i) {
     SetExplicitlyAllowedPorts(valid[i]);
     EXPECT_EQ(i, GetCountOfExplicitlyAllowedPorts());
   }
 }
 
 TEST(NetUtilTest, GetHostOrSpecFromURL) {
   EXPECT_EQ("example.com",
             GetHostOrSpecFromURL(GURL("http://example.com/test")));
   EXPECT_EQ("example.com",
             GetHostOrSpecFromURL(GURL("http://example.com./test")));
@@ skipping 192 matching lines @@
       "10.11.33.44/16",
       "::ffff:0a0b:89",
       true
     },
     {
       "10.11.33.44/16",
       "::ffff:10.12.33.44",
       false
     },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s, %s", i,
                                     tests[i].cidr_literal,
                                     tests[i].ip_literal));
 
     IPAddressNumber ip_number;
     EXPECT_TRUE(ParseIPLiteralToNumber(tests[i].ip_literal, &ip_number));
 
     IPAddressNumber ip_prefix;
     size_t prefix_length_in_bits;
 
@@ skipping 287 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