Convert ARRAYSIZE_UNSAFE -> arraysize in net/.

R=rsleevi@chromium.org
BUG=423134

Review URL: https://codereview.chromium.org/662553002

Cr-Commit-Position: refs/heads/master@{#299857}

45 files changed, 140 insertions, 142 deletions

diff --git a/net/base/address_list_unittest.cc b/net/base/address_list_unittest.cc
index 32c3e52..e559788 100644
--- a/net/base/address_list_unittest.cc
+++ b/net/base/address_list_unittest.cc
@@ -121,7 +121,7 @@ TEST(AddressListTest, CreateFromIPAddressList) {
 
   // Construct a list of ip addresses.
   IPAddressList ip_list;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     IPAddressNumber ip_number;
     ASSERT_TRUE(ParseIPLiteralToNumber(tests[i].ip_address, &ip_number));
     ip_list.push_back(ip_number);
@@ -131,7 +131,7 @@ TEST(AddressListTest, CreateFromIPAddressList) {
                                                                kCanonicalName);
   std::string canonical_name;
   EXPECT_EQ(kCanonicalName, test_list.canonical_name());
-  EXPECT_EQ(ARRAYSIZE_UNSAFE(tests), test_list.size());
+  EXPECT_EQ(arraysize(tests), test_list.size());
 }
 
 }  // namespace
diff --git a/net/base/escape.cc b/net/base/escape.cc
index 7ce21a1..1798b6c 100644
--- a/net/base/escape.cc
+++ b/net/base/escape.cc
@@ -244,7 +244,7 @@ void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) {
     { '\'', "&#39;" },
   };
   size_t k;
-  for (k = 0; k < ARRAYSIZE_UNSAFE(kCharsToEscape); ++k) {
+  for (k = 0; k < arraysize(kCharsToEscape); ++k) {
     if (c == kCharsToEscape[k].key) {
       const char* p = kCharsToEscape[k].replacement;
       while (*p)
@@ -252,7 +252,7 @@ void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) {
       break;
     }
   }
-  if (k == ARRAYSIZE_UNSAFE(kCharsToEscape))
+  if (k == arraysize(kCharsToEscape))
     output->push_back(c);
 }
 
@@ -385,14 +385,14 @@ base::string16 UnescapeForHTML(const base::string16& input) {
   if (input.find(base::ASCIIToUTF16("&")) == std::string::npos)
     return input;
 
-  base::string16 ampersand_chars[ARRAYSIZE_UNSAFE(kEscapeToChars)];
+  base::string16 ampersand_chars[arraysize(kEscapeToChars)];
   base::string16 text(input);
   for (base::string16::iterator iter = text.begin();
        iter != text.end(); ++iter) {
     if (*iter == '&') {
       // Potential ampersand encode char.
       size_t index = iter - text.begin();
-      for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEscapeToChars); i++) {
+      for (size_t i = 0; i < arraysize(kEscapeToChars); i++) {
         if (ampersand_chars[i].empty()) {
           ampersand_chars[i] =
               base::ASCIIToUTF16(kEscapeToChars[i].ampersand_code);
diff --git a/net/base/filename_util_unittest.cc b/net/base/filename_util_unittest.cc
index 2201033..965169a 100644
--- a/net/base/filename_util_unittest.cc
+++ b/net/base/filename_util_unittest.cc
@@ -183,7 +183,7 @@ TEST(FilenameUtilTest, FileURLConversion) {
 
   // First, we'll test that we can round-trip all of the above cases of URLs
   base::FilePath output;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(round_trip_cases); i++) {
+  for (size_t i = 0; i < arraysize(round_trip_cases); i++) {
     // convert to the file URL
     GURL file_url(FilePathToFileURL(
                       WStringAsFilePath(round_trip_cases[i].file)));
@@ -228,7 +228,7 @@ TEST(FilenameUtilTest, FileURLConversion) {
     //{L"/foo%5Cbar.txt", "file://foo\\bar.txt"},
 #endif
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_cases); i++) {
+  for (size_t i = 0; i < arraysize(url_cases); i++) {
     FileURLToFilePath(GURL(url_cases[i].url), &output);
     EXPECT_EQ(url_cases[i].file, FilePathAsWString(output));
   }
@@ -409,7 +409,7 @@ TEST(FilenameUtilTest, GenerateSafeFileName) {
 #endif  // !defined(OS_WIN)
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(safe_tests); ++i) {
+  for (size_t i = 0; i < arraysize(safe_tests); ++i) {
     base::FilePath file_path(safe_tests[i].filename);
     GenerateSafeFileName(safe_tests[i].mime_type, false, &file_path);
     EXPECT_EQ(safe_tests[i].expected_filename, file_path.value())
@@ -1651,13 +1651,13 @@ TEST(FilenameUtilTest, GenerateFileName) {
 #endif
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(selection_tests); ++i)
+  for (size_t i = 0; i < arraysize(selection_tests); ++i)
     RunGenerateFileNameTestCase(&selection_tests[i]);
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generation_tests); ++i)
+  for (size_t i = 0; i < arraysize(generation_tests); ++i)
     RunGenerateFileNameTestCase(&generation_tests[i]);
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generation_tests); ++i) {
+  for (size_t i = 0; i < arraysize(generation_tests); ++i) {
     GenerateFilenameCase test_case = generation_tests[i];
     test_case.referrer_charset = "GBK";
     RunGenerateFileNameTestCase(&test_case);
diff --git a/net/base/ip_endpoint_unittest.cc b/net/base/ip_endpoint_unittest.cc
index f10e8e9..5698cc4 100644
--- a/net/base/ip_endpoint_unittest.cc
+++ b/net/base/ip_endpoint_unittest.cc
@@ -29,7 +29,7 @@ struct TestData {
   { "::1", "[::1]", true },
   { "2001:db8:0::42", "[2001:db8::42]", true },
 };
-int test_count = ARRAYSIZE_UNSAFE(tests);
+int test_count = arraysize(tests);
 
 class IPEndPointTest : public PlatformTest {
  public:
diff --git a/net/base/mime_util_unittest.cc b/net/base/mime_util_unittest.cc
index 08a3dfd..49c4661 100644
--- a/net/base/mime_util_unittest.cc
+++ b/net/base/mime_util_unittest.cc
@@ -33,7 +33,7 @@ TEST(MimeUtilTest, ExtensionTest) {
   std::string mime_type;
   bool rv;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     rv = GetMimeTypeFromExtension(tests[i].extension, &mime_type);
     EXPECT_EQ(tests[i].valid, rv);
     if (rv)
@@ -58,7 +58,7 @@ TEST(MimeUtilTest, FileTest) {
   std::string mime_type;
   bool rv;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     rv = GetMimeTypeFromFile(base::FilePath(tests[i].file_path),
                                   &mime_type);
     EXPECT_EQ(tests[i].valid, rv);
@@ -274,7 +274,7 @@ TEST(MimeUtilTest, ParseCodecString) {
     { ",",                          2, { "", "" }             },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::vector<std::string> codecs_out;
     ParseCodecString(tests[i].original, &codecs_out, true);
     ASSERT_EQ(tests[i].expected_size, codecs_out.size());
@@ -401,7 +401,7 @@ TEST(MimeUtilTest, TestGetExtensionsForMimeType) {
     { "aUDIo/*",    6, "wav" },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::vector<base::FilePath::StringType> extensions;
     GetExtensionsForMimeType(tests[i].mime_type, &extensions);
     ASSERT_TRUE(tests[i].min_expected_size <= extensions.size());
diff --git a/net/base/net_log_logger.cc b/net/base/net_log_logger.cc
index 0c0f1c9..76b5b32 100644
--- a/net/base/net_log_logger.cc
+++ b/net/base/net_log_logger.cc
@@ -117,7 +117,7 @@ base::DictionaryValue* NetLogLogger::GetConstants() {
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kCertStatusFlags); i++)
+    for (size_t i = 0; i < arraysize(kCertStatusFlags); i++)
       dict->SetInteger(kCertStatusFlags[i].name, kCertStatusFlags[i].constant);
 
     constants_dict->Set("certStatusFlag", dict);
@@ -128,7 +128,7 @@ base::DictionaryValue* NetLogLogger::GetConstants() {
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kLoadFlags); i++)
+    for (size_t i = 0; i < arraysize(kLoadFlags); i++)
       dict->SetInteger(kLoadFlags[i].name, kLoadFlags[i].constant);
 
     constants_dict->Set("loadFlag", dict);
@@ -139,7 +139,7 @@ base::DictionaryValue* NetLogLogger::GetConstants() {
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kLoadStateTable); i++)
+    for (size_t i = 0; i < arraysize(kLoadStateTable); i++)
       dict->SetInteger(kLoadStateTable[i].name, kLoadStateTable[i].constant);
 
     constants_dict->Set("loadState", dict);
@@ -150,7 +150,7 @@ base::DictionaryValue* NetLogLogger::GetConstants() {
   {
     base::DictionaryValue* dict = new base::DictionaryValue();
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kNetErrors); i++)
+    for (size_t i = 0; i < arraysize(kNetErrors); i++)
       dict->SetInteger(ErrorToShortString(kNetErrors[i]), kNetErrors[i]);
 
     constants_dict->Set("netError", dict);
diff --git a/net/base/net_util_icu_unittest.cc b/net/base/net_util_icu_unittest.cc
index 9beb434..d92b9d1 100644
--- a/net/base/net_util_icu_unittest.cc
+++ b/net/base/net_util_icu_unittest.cc
@@ -411,7 +411,7 @@ void CheckAdjustedOffsets(const std::string& url_string,
 }  // anonymous namespace
 
 TEST(NetUtilTest, IDNToUnicodeFast) {
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(idn_cases); i++) {
+  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)
@@ -427,7 +427,7 @@ TEST(NetUtilTest, IDNToUnicodeFast) {
 }
 
 TEST(NetUtilTest, IDNToUnicodeSlow) {
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(idn_cases); i++) {
+  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))
@@ -506,7 +506,7 @@ TEST(NetUtilTest, GetDirectoryListingEntry) {
          ",0,\"9.8 kB\",\"\");</script>\n"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  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,
diff --git a/net/base/net_util_unittest.cc b/net/base/net_util_unittest.cc
index 0e17f1a..4883ff2 100644
--- a/net/base/net_util_unittest.cc
+++ b/net/base/net_util_unittest.cc
@@ -118,7 +118,7 @@ TEST(NetUtilTest, GetIdentityFromURL) {
       "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);
@@ -180,14 +180,14 @@ TEST(NetUtilTest, GetSpecificHeader) {
   };
 
   // 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());
   }
@@ -224,7 +224,7 @@ TEST(NetUtilTest, CompliantHost) {
     {"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));
   }
@@ -274,7 +274,7 @@ TEST(NetUtilTest, ParseHostAndPort) {
     {"[]", 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);
@@ -300,7 +300,7 @@ TEST(NetUtilTest, GetHostAndPort) {
     { 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);
   }
@@ -318,7 +318,7 @@ TEST(NetUtilTest, GetHostAndOptionalPort) {
     { 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);
   }
@@ -358,7 +358,7 @@ TEST(NetUtilTest, NetAddressToString_IPv4) {
     {{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);
@@ -376,7 +376,7 @@ TEST(NetUtilTest, NetAddressToString_IPv6) {
      "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),
@@ -452,7 +452,7 @@ TEST(NetUtilTest, SimplifyUrlForRequest) {
       "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));
@@ -465,12 +465,12 @@ 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());
   }
@@ -683,7 +683,7 @@ TEST(NetUtilTest, IPNumberMatchesPrefix) {
       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));
diff --git a/net/cert/multi_threaded_cert_verifier_unittest.cc b/net/cert/multi_threaded_cert_verifier_unittest.cc
index 651f78e..cdf9b1d 100644
--- a/net/cert/multi_threaded_cert_verifier_unittest.cc
+++ b/net/cert/multi_threaded_cert_verifier_unittest.cc
@@ -383,7 +383,7 @@ TEST_F(MultiThreadedCertVerifierTest, RequestParamsComparators) {
       -1,
     },
   };
-  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 "]", i));
 
     const MultiThreadedCertVerifier::RequestParams& key1 = tests[i].key1;
diff --git a/net/cookies/cookie_monster_perftest.cc b/net/cookies/cookie_monster_perftest.cc
index 2bc0be8..6e799ad 100644
--- a/net/cookies/cookie_monster_perftest.cc
+++ b/net/cookies/cookie_monster_perftest.cc
@@ -363,7 +363,7 @@ TEST_F(CookieMonsterTest, TestGCTimes) {
       0,
     },
   };
-  for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
+  for (int ci = 0; ci < static_cast<int>(arraysize(test_cases)); ++ci) {
     const TestCase& test_case(test_cases[ci]);
     scoped_refptr<CookieMonster> cm(
         CreateMonsterFromStoreForGC(
diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index a328487..34a50bb 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -1958,7 +1958,7 @@ TEST_F(CookieMonsterTest, BackingStoreCommunication) {
   {
     scoped_refptr<CookieMonster> cmout(new CookieMonster(store.get(), NULL));
     for (const CookiesInputInfo* p = input_info;
-         p < &input_info[ARRAYSIZE_UNSAFE(input_info)];
+         p < &input_info[arraysize(input_info)];
          p++) {
       EXPECT_TRUE(SetCookieWithDetails(cmout.get(),
                                        p->url,
@@ -2112,7 +2112,7 @@ TEST_F(CookieMonsterTest, MAYBE_GarbageCollectionTriggers) {
     }
   };
 
-  for (int ci = 0; ci < static_cast<int>(ARRAYSIZE_UNSAFE(test_cases)); ++ci) {
+  for (int ci = 0; ci < static_cast<int>(arraysize(test_cases)); ++ci) {
     const TestCase *test_case = &test_cases[ci];
     scoped_refptr<CookieMonster> cm(
         CreateMonsterFromStoreForGC(
diff --git a/net/cookies/cookie_util_unittest.cc b/net/cookies/cookie_util_unittest.cc
index 98c2061..fc27631 100644
--- a/net/cookies/cookie_util_unittest.cc
+++ b/net/cookies/cookie_util_unittest.cc
@@ -55,7 +55,7 @@ TEST(CookieUtilTest, TestDomainIsHostOnly) {
     { ".google.com",    false }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     EXPECT_EQ(tests[i].is_host_only,
               net::cookie_util::DomainIsHostOnly(tests[i].str));
   }
@@ -138,7 +138,7 @@ TEST(CookieUtilTest, TestCookieDateParsing) {
   };
 
   base::Time parsed_time;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     parsed_time = net::cookie_util::ParseCookieTime(tests[i].str);
     if (!tests[i].valid) {
       EXPECT_FALSE(!parsed_time.is_null()) << tests[i].str;
diff --git a/net/dns/dns_hosts_unittest.cc b/net/dns/dns_hosts_unittest.cc
index 9074899..1bce190 100644
--- a/net/dns/dns_hosts_unittest.cc
+++ b/net/dns/dns_hosts_unittest.cc
@@ -66,7 +66,7 @@ TEST(DnsHostsTest, ParseHosts) {
   };
 
   DnsHosts expected_hosts, actual_hosts;
-  PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts);
+  PopulateExpectedHosts(kEntries, arraysize(kEntries), &expected_hosts);
   ParseHosts(kContents, &actual_hosts);
   ASSERT_EQ(expected_hosts, actual_hosts);
 }
@@ -79,7 +79,7 @@ TEST(DnsHostsTest, ParseHosts_CommaIsToken) {
   };
 
   DnsHosts expected_hosts, actual_hosts;
-  PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts);
+  PopulateExpectedHosts(kEntries, arraysize(kEntries), &expected_hosts);
   ParseHostsWithCommaModeForTesting(
       kContents, &actual_hosts, PARSE_HOSTS_COMMA_IS_TOKEN);
   ASSERT_EQ(expected_hosts, actual_hosts);
@@ -94,7 +94,7 @@ TEST(DnsHostsTest, ParseHosts_CommaIsWhitespace) {
   };
 
   DnsHosts expected_hosts, actual_hosts;
-  PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts);
+  PopulateExpectedHosts(kEntries, arraysize(kEntries), &expected_hosts);
   ParseHostsWithCommaModeForTesting(
       kContents, &actual_hosts, PARSE_HOSTS_COMMA_IS_WHITESPACE);
   ASSERT_EQ(expected_hosts, actual_hosts);
@@ -116,7 +116,7 @@ TEST(DnsHostsTest, ParseHosts_CommaModeByPlatform) {
 #endif
 
   DnsHosts expected_hosts, actual_hosts;
-  PopulateExpectedHosts(kEntries, ARRAYSIZE_UNSAFE(kEntries), &expected_hosts);
+  PopulateExpectedHosts(kEntries, arraysize(kEntries), &expected_hosts);
   ParseHosts(kContents, &actual_hosts);
   ASSERT_EQ(expected_hosts, actual_hosts);
 }
diff --git a/net/dns/dns_response_unittest.cc b/net/dns/dns_response_unittest.cc
index 12b0377..6ecfac4 100644
--- a/net/dns/dns_response_unittest.cc
+++ b/net/dns/dns_response_unittest.cc
@@ -441,7 +441,7 @@ TEST(DnsResponseTest, ParseToAddressList) {
       },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     const TestCase& t = cases[i];
     DnsResponse response(t.response_data, t.response_size, t.query_size);
     AddressList addr_list;
@@ -565,7 +565,7 @@ TEST(DnsResponseTest, ParseToAddressListFail) {
 
   const size_t kQuerySize = 12 + 7;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     const TestCase& t = cases[i];
 
     DnsResponse response(t.data, t.size, kQuerySize);
diff --git a/net/dns/host_cache_unittest.cc b/net/dns/host_cache_unittest.cc
index 34309c1..838fedc 100644
--- a/net/dns/host_cache_unittest.cc
+++ b/net/dns/host_cache_unittest.cc
@@ -360,7 +360,7 @@ TEST(HostCacheTest, KeyComparators) {
     },
   };
 
-  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 "]", i));
 
     const HostCache::Key& key1 = tests[i].key1;
diff --git a/net/ftp/ftp_directory_listing_parser.cc b/net/ftp/ftp_directory_listing_parser.cc
index d19e4a2..fa6e8a5 100644
--- a/net/ftp/ftp_directory_listing_parser.cc
+++ b/net/ftp/ftp_directory_listing_parser.cc
@@ -77,7 +77,7 @@ int ParseListing(const base::string16& text,
     }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(parsers); i++) {
+  for (size_t i = 0; i < arraysize(parsers); i++) {
     entries->clear();
     if (parsers[i].callback.Run()) {
       *server_type = parsers[i].server_type;
diff --git a/net/ftp/ftp_util_unittest.cc b/net/ftp/ftp_util_unittest.cc
index 5851e88..a2b2849 100644
--- a/net/ftp/ftp_util_unittest.cc
+++ b/net/ftp/ftp_util_unittest.cc
@@ -34,7 +34,7 @@ TEST(FtpUtilTest, UnixFilePathToVMS) {
     { "a/b/c",      "[.a.b]c"     },
     { "a/b/c/d",    "[.a.b.c]d"   },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               net::FtpUtil::UnixFilePathToVMS(kTestCases[i].input))
         << kTestCases[i].input;
@@ -67,7 +67,7 @@ TEST(FtpUtilTest, UnixDirectoryPathToVMS) {
     { "a/b/c/d",     "[.a.b.c.d]"  },
     { "a/b/c/d/",    "[.a.b.c.d]"  },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               net::FtpUtil::UnixDirectoryPathToVMS(kTestCases[i].input))
         << kTestCases[i].input;
@@ -107,7 +107,7 @@ TEST(FtpUtilTest, VMSPathToUnix) {
     { "/a/b/c",      "/a/b/c"     },
     { "/a/b/c/d",    "/a/b/c/d"   },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               net::FtpUtil::VMSPathToUnix(kTestCases[i].input))
         << kTestCases[i].input;
@@ -163,7 +163,7 @@ TEST(FtpUtilTest, LsDateListingToTime) {
     { "Sep", "02", "09:00", 1994, 9, 2, 9, 0 },
     { "Dec", "06", "21:00", 1993, 12, 6, 21, 0 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %s %s", i,
                                     kTestCases[i].month, kTestCases[i].day,
                                     kTestCases[i].rest));
@@ -204,7 +204,7 @@ TEST(FtpUtilTest, WindowsDateListingToTime) {
 
     { "11-01-2007", "12:42", 2007, 11, 1, 12, 42 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %s", i,
                                     kTestCases[i].date, kTestCases[i].time));
 
@@ -243,7 +243,7 @@ TEST(FtpUtilTest, GetStringPartAfterColumns) {
     { "  foo   abc ", 1, "abc" },
     { "  foo   abc ", 2, "" },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %d", i,
                                     kTestCases[i].text, kTestCases[i].column));
 
diff --git a/net/http/http_auth_handler_basic_unittest.cc b/net/http/http_auth_handler_basic_unittest.cc
index 6f112b1..a369df3 100644
--- a/net/http/http_auth_handler_basic_unittest.cc
+++ b/net/http/http_auth_handler_basic_unittest.cc
@@ -32,7 +32,7 @@ TEST(HttpAuthHandlerBasicTest, GenerateAuthToken) {
   };
   GURL origin("http://www.example.com");
   HttpAuthHandlerBasic::Factory factory;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string challenge = "Basic realm=\"Atlantis\"";
     scoped_ptr<HttpAuthHandler> basic;
     EXPECT_EQ(OK, factory.CreateAuthHandlerFromString(
@@ -90,7 +90,7 @@ TEST(HttpAuthHandlerBasicTest, HandleAnotherChallenge) {
       tests[0].challenge, HttpAuth::AUTH_SERVER, origin,
       BoundNetLog(), &basic));
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string challenge(tests[i].challenge);
     HttpAuthChallengeTokenizer tok(challenge.begin(),
                                    challenge.end());
@@ -183,7 +183,7 @@ TEST(HttpAuthHandlerBasicTest, InitFromChallenge) {
   };
   HttpAuthHandlerBasic::Factory factory;
   GURL origin("http://www.example.com");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string challenge = tests[i].challenge;
     scoped_ptr<HttpAuthHandler> basic;
     int rv = factory.CreateAuthHandlerFromString(
diff --git a/net/http/http_auth_handler_digest_unittest.cc b/net/http/http_auth_handler_digest_unittest.cc
index 5c3941c..8b5179e 100644
--- a/net/http/http_auth_handler_digest_unittest.cc
+++ b/net/http/http_auth_handler_digest_unittest.cc
@@ -351,7 +351,7 @@ TEST(HttpAuthHandlerDigestTest, ParseChallenge) {
   GURL origin("http://www.example.com");
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     scoped_ptr<HttpAuthHandler> handler;
     int rv = factory->CreateAuthHandlerFromString(tests[i].challenge,
                                                   HttpAuth::AUTH_SERVER,
@@ -516,7 +516,7 @@ TEST(HttpAuthHandlerDigestTest, AssembleCredentials) {
   GURL origin("http://www.example.com");
   scoped_ptr<HttpAuthHandlerDigest::Factory> factory(
       new HttpAuthHandlerDigest::Factory());
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     scoped_ptr<HttpAuthHandler> handler;
     int rv = factory->CreateAuthHandlerFromString(tests[i].challenge,
                                                   HttpAuth::AUTH_SERVER,
diff --git a/net/http/http_auth_unittest.cc b/net/http/http_auth_unittest.cc
index cf68fa8..52e8294 100644
--- a/net/http/http_auth_unittest.cc
+++ b/net/http/http_auth_unittest.cc
@@ -129,7 +129,7 @@ TEST(HttpAuthTest, ChooseBestChallenge) {
   http_auth_handler_factory->SetURLSecurityManager(
       "negotiate", &url_security_manager);
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     // Make a HttpResponseHeaders object.
     std::string headers_with_status_line("HTTP/1.1 401 Unauthorized\n");
     headers_with_status_line += tests[i].headers;
diff --git a/net/http/http_byte_range_unittest.cc b/net/http/http_byte_range_unittest.cc
index 5dc6e52..d075294 100644
--- a/net/http/http_byte_range_unittest.cc
+++ b/net/http/http_byte_range_unittest.cc
@@ -23,7 +23,7 @@ TEST(HttpByteRangeTest, ValidRanges) {
     {  -1, -1, 100000, true },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::HttpByteRange range;
     range.set_first_byte_position(tests[i].first_byte_position);
     range.set_last_byte_position(tests[i].last_byte_position);
@@ -55,7 +55,7 @@ TEST(HttpByteRangeTest, SetInstanceSize) {
     {  10, 10000, -1, 1000000, true, 10, 10000 },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::HttpByteRange range;
     range.set_first_byte_position(tests[i].first_byte_position);
     range.set_last_byte_position(tests[i].last_byte_position);
@@ -86,7 +86,7 @@ TEST(HttpByteRangeTest, GetHeaderValue) {
                {net::HttpByteRange::Bounded(0, -1),      "bytes=0-"},
                {net::HttpByteRange::RightUnbounded(100), "bytes=100-"},
                {net::HttpByteRange::Suffix(100),         "bytes=-100"}, };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     EXPECT_EQ(tests[i].expected, tests[i].range.GetHeaderValue());
   }
 }
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index ddd0481..5441e90 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -2015,7 +2015,7 @@ void HttpCache::Transaction::SetRequest(const BoundNetLog& net_log,
   if (request_->extra_headers.HasHeader(HttpRequestHeaders::kRange))
     range_found = true;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSpecialHeaders); ++i) {
+  for (size_t i = 0; i < arraysize(kSpecialHeaders); ++i) {
     if (HeaderMatches(request_->extra_headers, kSpecialHeaders[i].search)) {
       effective_load_flags_ |= kSpecialHeaders[i].load_flag;
       break;
diff --git a/net/http/http_content_disposition_unittest.cc b/net/http/http_content_disposition_unittest.cc
index 43fef9d..e617c6c 100644
--- a/net/http/http_content_disposition_unittest.cc
+++ b/net/http/http_content_disposition_unittest.cc
@@ -195,7 +195,7 @@ TEST(HttpContentDispositionTest, Filename) {
     {"attachment; foobar=x; filename=\"foo.html\"", "",
       L"foo.html"},
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     HttpContentDisposition header(tests[i].header, tests[i].referrer_charset);
     EXPECT_EQ(tests[i].expected,
         base::UTF8ToWide(header.filename()))
@@ -503,7 +503,7 @@ TEST(HttpContentDispositionTest, tc2231) {
     // TODO(abarth): http://greenbytes.de/tech/tc2231/#attrfc2047token
     // TODO(abarth): http://greenbytes.de/tech/tc2231/#attrfc2047quoted
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     HttpContentDisposition header(tests[i].header, std::string());
     EXPECT_EQ(tests[i].expected_type, header.type())
         << "Failed on input: " << tests[i].header;
@@ -576,7 +576,7 @@ TEST(HttpContentDispositionTest, ParseResult) {
       HttpContentDisposition::HAS_NAME },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     const ParseResultTestCase& test_case = kTestCases[i];
     HttpContentDisposition content_disposition(test_case.header, "utf-8");
     int result = content_disposition.parse_result_flags();
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index 4aa309d..ca26d6f 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -7601,7 +7601,7 @@ TEST_P(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
 
   session_deps_.use_alternate_protocols = true;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service.reset(
         ProxyService::CreateFixed(tests[i].proxy_server));
     scoped_refptr<HttpNetworkSession> session(
@@ -7664,7 +7664,7 @@ TEST_P(HttpNetworkTransactionTest, GroupNameForHTTPProxyConnections) {
 
   session_deps_.use_alternate_protocols = true;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service.reset(
         ProxyService::CreateFixed(tests[i].proxy_server));
     scoped_refptr<HttpNetworkSession> session(
@@ -7734,7 +7734,7 @@ TEST_P(HttpNetworkTransactionTest, GroupNameForSOCKSConnections) {
 
   session_deps_.use_alternate_protocols = true;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     session_deps_.proxy_service.reset(
         ProxyService::CreateFixed(tests[i].proxy_server));
     scoped_refptr<HttpNetworkSession> session(
@@ -9652,7 +9652,7 @@ TEST_P(HttpNetworkTransactionTest, GenerateAuthToken) {
         TestRound(kGetAuth, kFailure, kAuthErr)}},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_configs); ++i) {
+  for (size_t i = 0; i < arraysize(test_configs); ++i) {
     HttpAuthHandlerMock::Factory* auth_factory(
         new HttpAuthHandlerMock::Factory());
     session_deps_.http_auth_handler_factory.reset(auth_factory);
diff --git a/net/http/http_util_unittest.cc b/net/http/http_util_unittest.cc
index 54acf68..acb2693 100644
--- a/net/http/http_util_unittest.cc
+++ b/net/http/http_util_unittest.cc
@@ -114,7 +114,7 @@ TEST(HttpUtilTest, HasHeader) {
     { "fOO: 1\r\nbar: 2", "foo", true },
     { "g: 0\r\nfoo: 1\r\nbar: 2", "foo", true },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     bool result = HttpUtil::HasHeader(tests[i].headers, tests[i].name);
     EXPECT_EQ(tests[i].expected_result, result);
   }
@@ -272,7 +272,7 @@ TEST(HttpUtilTest, LocateEndOfHeaders) {
     { "foo\nbar\n\r\njunk", 10 },
     { "foo\nbar\r\n\njunk", 10 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     int input_len = static_cast<int>(strlen(tests[i].input));
     int eoh = HttpUtil::LocateEndOfHeaders(tests[i].input, input_len);
     EXPECT_EQ(tests[i].expected_result, eoh);
@@ -582,7 +582,7 @@ TEST(HttpUtilTest, AssembleRawHeaders) {
       "HTTP/1.0 200 OK|Foo: 1Foo2: 3|Bar: 2||"
     },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string input = tests[i].input;
     std::replace(input.begin(), input.end(), '|', '\0');
     std::string raw = HttpUtil::AssembleRawHeaders(input.data(), input.size());
@@ -629,7 +629,7 @@ TEST(HttpUtilTest, RequestUrlSanitize) {
       "/foobar?query=1"
     }
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     GURL url(GURL(tests[i].url));
     std::string expected_spec(tests[i].expected_spec);
     std::string expected_path(tests[i].expected_path);
@@ -725,7 +725,7 @@ TEST(HttpUtilTest, ParseContentType) {
     },
     // TODO(abarth): Add more interesting test cases.
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::string mime_type;
     std::string charset;
     bool had_charset = false;
@@ -853,7 +853,7 @@ TEST(HttpUtilTest, ParseRanges) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     std::vector<net::HttpByteRange> ranges;
     bool return_value = HttpUtil::ParseRanges(std::string(tests[i].headers),
                                               &ranges);
diff --git a/net/proxy/proxy_bypass_rules_unittest.cc b/net/proxy/proxy_bypass_rules_unittest.cc
index 40758fd..c099ad6 100644
--- a/net/proxy/proxy_bypass_rules_unittest.cc
+++ b/net/proxy/proxy_bypass_rules_unittest.cc
@@ -275,7 +275,7 @@ TEST(ProxyBypassRulesTest, BypassLocalNames) {
   ProxyBypassRules rules;
   rules.ParseFromString("<local>");
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     SCOPED_TRACE(base::StringPrintf(
         "Test[%d]: %s", static_cast<int>(i), tests[i].url));
     EXPECT_EQ(tests[i].expected_is_local, rules.Matches(GURL(tests[i].url)));
diff --git a/net/proxy/proxy_config_service_linux_unittest.cc b/net/proxy/proxy_config_service_linux_unittest.cc
index cfb0cff..3e6b966 100644
--- a/net/proxy/proxy_config_service_linux_unittest.cc
+++ b/net/proxy/proxy_config_service_linux_unittest.cc
@@ -681,7 +681,7 @@ TEST_F(ProxyConfigServiceLinuxTest, BasicGConfTest) {
     },
   };
 
-  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].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
@@ -989,7 +989,7 @@ TEST_F(ProxyConfigServiceLinuxTest, BasicEnvTest) {
     },
   };
 
-  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].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
@@ -1493,7 +1493,7 @@ TEST_F(ProxyConfigServiceLinuxTest, KDEConfigParser) {
 
   };
 
-  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].description.c_str()));
     MockEnvironment* env = new MockEnvironment;
diff --git a/net/proxy/proxy_config_service_win_unittest.cc b/net/proxy/proxy_config_service_win_unittest.cc
index f133500..0248638 100644
--- a/net/proxy/proxy_config_service_win_unittest.cc
+++ b/net/proxy/proxy_config_service_win_unittest.cc
@@ -196,7 +196,7 @@ TEST(ProxyConfigServiceWinTest, SetFromIEConfig) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     WINHTTP_CURRENT_USER_IE_PROXY_CONFIG ie_config = {
         tests[i].ie_config.auto_detect,
         const_cast<wchar_t*>(tests[i].ie_config.auto_config_url),
diff --git a/net/proxy/proxy_config_source.cc b/net/proxy/proxy_config_source.cc
index 5695b9b..f47c2f6 100644
--- a/net/proxy/proxy_config_source.cc
+++ b/net/proxy/proxy_config_source.cc
@@ -22,7 +22,7 @@ const char* kSourceNames[] = {
   "CUSTOM",
   "TEST"
 };
-COMPILE_ASSERT(ARRAYSIZE_UNSAFE(kSourceNames) == NUM_PROXY_CONFIG_SOURCES,
+COMPILE_ASSERT(arraysize(kSourceNames) == NUM_PROXY_CONFIG_SOURCES,
                source_names_incorrect_size);
 
 }  // namespace
diff --git a/net/proxy/proxy_config_unittest.cc b/net/proxy/proxy_config_unittest.cc
index 4b041b3..fb349b3 100644
--- a/net/proxy/proxy_config_unittest.cc
+++ b/net/proxy/proxy_config_unittest.cc
@@ -308,7 +308,7 @@ TEST(ProxyConfigTest, ParseProxyRules) {
 
   ProxyConfig config;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     config.proxy_rules().ParseFromString(tests[i].proxy_rules);
 
     EXPECT_EQ(tests[i].type, config.proxy_rules().type);
diff --git a/net/proxy/proxy_list_unittest.cc b/net/proxy/proxy_list_unittest.cc
index 23b823f..5b759b1 100644
--- a/net/proxy/proxy_list_unittest.cc
+++ b/net/proxy/proxy_list_unittest.cc
@@ -58,7 +58,7 @@ TEST(ProxyListTest, SetFromPacString) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     ProxyList list;
     list.SetFromPacString(tests[i].pac_input);
     EXPECT_EQ(tests[i].pac_output, list.ToPacString());
@@ -84,7 +84,7 @@ TEST(ProxyListTest, RemoveProxiesWithoutScheme) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     ProxyList list;
     list.SetFromPacString(tests[i].pac_input);
     list.RemoveProxiesWithoutScheme(tests[i].filter);
diff --git a/net/proxy/proxy_server_unittest.cc b/net/proxy/proxy_server_unittest.cc
index 7646467..2471b59 100644
--- a/net/proxy/proxy_server_unittest.cc
+++ b/net/proxy/proxy_server_unittest.cc
@@ -159,7 +159,7 @@ TEST(ProxyServerTest, FromURI) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri =
         net::ProxyServer::FromURI(tests[i].input_uri,
                                   net::ProxyServer::SCHEME_HTTP);
@@ -202,7 +202,7 @@ TEST(ProxyServerTest, Invalid) {
     "http:",  // ambiguous, but will fail because of bad port.
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri =
         net::ProxyServer::FromURI(tests[i], net::ProxyServer::SCHEME_HTTP);
     EXPECT_FALSE(uri.is_valid());
@@ -220,7 +220,7 @@ TEST(ProxyServerTest, Whitespace) {
     "  \tfoopy:80  ",
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri =
         net::ProxyServer::FromURI(tests[i], net::ProxyServer::SCHEME_HTTP);
     EXPECT_EQ("foopy:80", uri.ToURI());
@@ -279,7 +279,7 @@ TEST(ProxyServerTest, FromPACString) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri = net::ProxyServer::FromPacString(tests[i].input_pac);
     EXPECT_TRUE(uri.is_valid());
     EXPECT_EQ(tests[i].expected_uri, uri.ToURI());
@@ -295,7 +295,7 @@ TEST(ProxyServerTest, FromPACStringInvalid) {
     "DIRECT foopy:10",  // direct cannot have host/port.
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     net::ProxyServer uri = net::ProxyServer::FromPacString(tests[i]);
     EXPECT_FALSE(uri.is_valid());
   }
@@ -335,7 +335,7 @@ TEST(ProxyServerTest, ComparatorAndEquality) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     // Parse the expected inputs to ProxyServer instances.
     const net::ProxyServer server1 =
         net::ProxyServer::FromURI(
diff --git a/net/quic/crypto/crypto_utils_test.cc b/net/quic/crypto/crypto_utils_test.cc
index fd9f005..882a9b5 100644
--- a/net/quic/crypto/crypto_utils_test.cc
+++ b/net/quic/crypto/crypto_utils_test.cc
@@ -39,7 +39,7 @@ TEST(CryptoUtilsTest, NormalizeHostname) {
     { "www.google.com........", "www.google.com", },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     EXPECT_EQ(std::string(tests[i].expected),
               CryptoUtils::NormalizeHostname(tests[i].input));
   }
@@ -93,7 +93,7 @@ TEST(CryptoUtilsTest, TestExportKeyingMaterial) {
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_vector); i++) {
+  for (size_t i = 0; i < arraysize(test_vector); i++) {
     // Decode the test vector.
     string subkey_secret;
     string label;
diff --git a/net/quic/iovector_test.cc b/net/quic/iovector_test.cc
index e6cc058e..37a1523 100644
--- a/net/quic/iovector_test.cc
+++ b/net/quic/iovector_test.cc
@@ -23,7 +23,7 @@ const char* const test_data[] = {
 
 TEST(IOVectorTest, CopyConstructor) {
   IOVector iov1;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
   }
   IOVector iov2 = iov1;
@@ -37,7 +37,7 @@ TEST(IOVectorTest, CopyConstructor) {
 
 TEST(IOVectorTest, AssignmentOperator) {
   IOVector iov1;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     iov1.Append(const_cast<char*>(test_data[i]), strlen(test_data[i]));
   }
   IOVector iov2;
@@ -60,7 +60,7 @@ TEST(IOVectorTest, Append) {
 
   ASSERT_EQ(0u, iov.Size());
   ASSERT_TRUE(iov2 == nullptr);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     const int str_len = strlen(test_data[i]);
     const int append_len = str_len / 2;
     // This should append a new block
@@ -91,8 +91,8 @@ TEST(IOVectorTest, AppendIovec) {
     {const_cast<char*>("bar"), 3},
     {const_cast<char*>("buzzzz"), 6}
   };
-  iov.AppendIovec(test_iov, ARRAYSIZE_UNSAFE(test_iov));
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
+  iov.AppendIovec(test_iov, arraysize(test_iov));
+  for (size_t i = 0; i < arraysize(test_iov); ++i) {
     EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
     EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
   }
@@ -100,14 +100,13 @@ TEST(IOVectorTest, AppendIovec) {
   // Test AppendIovecAtMostBytes.
   iov.Clear();
   // Stop in the middle of a block.
-  EXPECT_EQ(5u, iov.AppendIovecAtMostBytes(test_iov, ARRAYSIZE_UNSAFE(test_iov),
-                                           5));
+  EXPECT_EQ(5u, iov.AppendIovecAtMostBytes(test_iov, arraysize(test_iov), 5));
   EXPECT_EQ(5u, iov.TotalBufferSize());
   iov.Append(static_cast<char*>(test_iov[1].iov_base) + 2, 1);
   // Make sure the boundary case, where max_bytes == size of block also works.
   EXPECT_EQ(6u, iov.AppendIovecAtMostBytes(&test_iov[2], 1, 6));
-  ASSERT_LE(ARRAYSIZE_UNSAFE(test_iov), static_cast<size_t>(iov.Size()));
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_iov); ++i) {
+  ASSERT_LE(arraysize(test_iov), static_cast<size_t>(iov.Size()));
+  for (size_t i = 0; i < arraysize(test_iov); ++i) {
     EXPECT_EQ(test_iov[i].iov_base, iov.iovec()[i].iov_base);
     EXPECT_EQ(test_iov[i].iov_len, iov.iovec()[i].iov_len);
   }
@@ -117,13 +116,13 @@ TEST(IOVectorTest, ConsumeHalfBlocks) {
   IOVector iov;
   int length = 0;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     const int str_len = strlen(test_data[i]);
     iov.Append(const_cast<char*>(test_data[i]), str_len);
     length += str_len;
   }
   const char* endp = iov.LastBlockEnd();
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     const struct iovec* iov2 = iov.iovec();
     const size_t str_len = strlen(test_data[i]);
     size_t tmp = str_len / 2;
@@ -135,7 +134,7 @@ TEST(IOVectorTest, ConsumeHalfBlocks) {
     // Consume half of the first block.
     size_t consumed = iov.Consume(tmp);
     ASSERT_EQ(tmp, consumed);
-    ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data) - i, static_cast<size_t>(iov.Size()));
+    ASSERT_EQ(arraysize(test_data) - i, static_cast<size_t>(iov.Size()));
     iov2 = iov.iovec();
     ASSERT_TRUE(iov2 != nullptr);
     ASSERT_TRUE(iov2[0].iov_base == test_data[i] + tmp);
@@ -144,8 +143,7 @@ TEST(IOVectorTest, ConsumeHalfBlocks) {
     // Consume the rest of the first block
     consumed = iov.Consume(str_len - tmp);
     ASSERT_EQ(str_len - tmp, consumed);
-    ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data) - i - 1,
-              static_cast<size_t>(iov.Size()));
+    ASSERT_EQ(arraysize(test_data) - i - 1, static_cast<size_t>(iov.Size()));
     iov2 = iov.iovec();
     if (iov.Size() > 0) {
       ASSERT_TRUE(iov2 != nullptr);
@@ -161,12 +159,12 @@ TEST(IOVectorTest, ConsumeTwoAndHalfBlocks) {
   IOVector iov;
   int length = 0;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     const int str_len = strlen(test_data[i]);
     iov.Append(const_cast<char*>(test_data[i]), str_len);
     length += str_len;
   }
-  const size_t last_len = strlen(test_data[ARRAYSIZE_UNSAFE(test_data) - 1]);
+  const size_t last_len = strlen(test_data[arraysize(test_data) - 1]);
   const size_t half_len = last_len / 2;
 
   const char* endp = iov.LastBlockEnd();
@@ -176,7 +174,7 @@ TEST(IOVectorTest, ConsumeTwoAndHalfBlocks) {
   ASSERT_TRUE(iov2 != nullptr);
   ASSERT_EQ(1u, iov.Size());
   ASSERT_TRUE(iov2[0].iov_base ==
-              test_data[ARRAYSIZE_UNSAFE(test_data) - 1] + last_len - half_len);
+              test_data[arraysize(test_data) - 1] + last_len - half_len);
   ASSERT_EQ(half_len, iov2[0].iov_len);
   ASSERT_TRUE(iov.LastBlockEnd() == endp);
 
@@ -192,7 +190,7 @@ TEST(IOVectorTest, ConsumeTooMuch) {
   IOVector iov;
   int length = 0;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     const int str_len = strlen(test_data[i]);
     iov.Append(const_cast<char*>(test_data[i]), str_len);
     length += str_len;
@@ -217,14 +215,14 @@ TEST(IOVectorTest, Clear) {
   IOVector iov;
   int length = 0;
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     const int str_len = strlen(test_data[i]);
     iov.Append(const_cast<char*>(test_data[i]), str_len);
     length += str_len;
   }
   const struct iovec* iov2 = iov.iovec();
   ASSERT_TRUE(iov2 != nullptr);
-  ASSERT_EQ(ARRAYSIZE_UNSAFE(test_data), static_cast<size_t>(iov.Size()));
+  ASSERT_EQ(arraysize(test_data), static_cast<size_t>(iov.Size()));
 
   iov.Clear();
   iov2 = iov.iovec();
diff --git a/net/quic/quic_socket_address_coder_test.cc b/net/quic/quic_socket_address_coder_test.cc
index 56bed58..cbfac2b 100644
--- a/net/quic/quic_socket_address_coder_test.cc
+++ b/net/quic/quic_socket_address_coder_test.cc
@@ -100,7 +100,7 @@ TEST(QuicSocketAddressCoderTest, EncodeAndDecode) {
     { "::1", 65534 },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_case); i++) {
+  for (size_t i = 0; i < arraysize(test_case); i++) {
     IPAddressNumber ip;
     ASSERT_TRUE(ParseIPLiteralToNumber(test_case[i].ip_literal, &ip));
     QuicSocketAddressCoder encoder(IPEndPoint(ip, test_case[i].port));
diff --git a/net/quic/quic_utils_test.cc b/net/quic/quic_utils_test.cc
index 0a0355f..b7d23ed 100644
--- a/net/quic/quic_utils_test.cc
+++ b/net/quic/quic_utils_test.cc
@@ -53,7 +53,7 @@ TEST(QuicUtilsTest, StringToHexASCIIDumpArgTypes) {
       "0x0000:  6f72 6967 696e 616c                      original\n", },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     EXPECT_EQ(tests[i].expected,
               QuicUtils::StringToHexASCIIDump(tests[i].input.c_str()));
     EXPECT_EQ(tests[i].expected,
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index e3dc359..84aaf6f 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -214,7 +214,7 @@ TEST_F(SOCKSClientSocketTest, HandshakeFailures) {
 
   //---------------------------------------
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
+  for (size_t i = 0; i < arraysize(tests); ++i) {
     MockWrite data_writes[] = {
         MockWrite(SYNCHRONOUS, kSOCKSOkRequest, arraysize(kSOCKSOkRequest)) };
     MockRead data_reads[] = {
diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc
index 54b4ee1..202cd88 100644
--- a/net/socket/ssl_client_socket_pool_unittest.cc
+++ b/net/socket/ssl_client_socket_pool_unittest.cc
@@ -1279,7 +1279,7 @@ TEST_P(SSLClientSocketPoolTest, IPPooling) {
   };
 
   host_resolver_.set_synchronous_mode(true);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
+  for (size_t i = 0; i < arraysize(test_hosts); i++) {
     host_resolver_.rules()->AddIPLiteralRule(
         test_hosts[i].name, test_hosts[i].iplist, std::string());
 
@@ -1339,7 +1339,7 @@ void SSLClientSocketPoolTest::TestIPPoolingDisabled(
 
   TestCompletionCallback callback;
   int rv;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
+  for (size_t i = 0; i < arraysize(test_hosts); i++) {
     host_resolver_.rules()->AddIPLiteralRule(
         test_hosts[i].name, test_hosts[i].iplist, std::string());
 
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index 92188ac..fc1b165 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -3238,7 +3238,7 @@ TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) {
     test_cases[2].expected_headers["version"] = "HTTP/1.1";
   }
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     MockWrite writes[] = { CreateMockWrite(*req) };
@@ -3351,7 +3351,7 @@ TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
     }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     // Construct the request.
     scoped_ptr<SpdyFrame> frame_req(
         spdy_util_.ConstructSpdyGet(test_cases[i].extra_headers[0],
@@ -3455,7 +3455,7 @@ TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
     { 0, { NULL }, },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     scoped_ptr<SpdyFrame> rst(
@@ -3511,7 +3511,7 @@ TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
     { syn_reply_wrong_length.get(), },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     scoped_ptr<SpdyFrame> req(
         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
     scoped_ptr<SpdyFrame> rst(
diff --git a/net/spdy/spdy_session_pool_unittest.cc b/net/spdy/spdy_session_pool_unittest.cc
index ece5d34..0a9903c 100644
--- a/net/spdy/spdy_session_pool_unittest.cc
+++ b/net/spdy/spdy_session_pool_unittest.cc
@@ -339,7 +339,7 @@ void SpdySessionPoolTest::RunIPPoolingTest(
   };
 
   session_deps_.host_resolver->set_synchronous_mode(true);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
+  for (size_t i = 0; i < arraysize(test_hosts); i++) {
     session_deps_.host_resolver->rules()->AddIPLiteralRule(
         test_hosts[i].name, test_hosts[i].iplist, std::string());
 
diff --git a/net/udp/udp_socket_unittest.cc b/net/udp/udp_socket_unittest.cc
index 100692c..83689c7 100644
--- a/net/udp/udp_socket_unittest.cc
+++ b/net/udp/udp_socket_unittest.cc
@@ -441,7 +441,7 @@ TEST_F(UDPSocketTest, ClientGetLocalPeerAddresses) {
     { "2001:db8:0::42", "::1", true },
 #endif
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
+  for (size_t i = 0; i < arraysize(tests); i++) {
     SCOPED_TRACE(std::string("Connecting from ") +  tests[i].local_address +
                  std::string(" to ") + tests[i].remote_address);
 
diff --git a/net/url_request/url_request_throttler_simulation_unittest.cc b/net/url_request/url_request_throttler_simulation_unittest.cc
index 2f3abbf..129a776 100644
--- a/net/url_request/url_request_throttler_simulation_unittest.cc
+++ b/net/url_request/url_request_throttler_simulation_unittest.cc
@@ -718,7 +718,7 @@ TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
   // If things don't converge by the time we've done 100K trials, then
   // clearly one or more of the expected intervals are wrong.
   while (global_stats.num_runs < 100000) {
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(trials); ++i) {
+    for (size_t i = 0; i < arraysize(trials); ++i) {
       ++global_stats.num_runs;
       ++trials[i].stats.num_runs;
       double ratio_unprotected = SimulateDowntime(
@@ -746,7 +746,7 @@ TEST(URLRequestThrottlerSimulation, PerceivedDowntimeRatio) {
 
   // Print individual trial results for optional manual evaluation.
   double max_increase_ratio = 0.0;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(trials); ++i) {
+  for (size_t i = 0; i < arraysize(trials); ++i) {
     double increase_ratio;
     trials[i].stats.DidConverge(&increase_ratio);
     max_increase_ratio = std::max(max_increase_ratio, increase_ratio);
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 0f64a7c..5756801 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -6342,7 +6342,7 @@ TEST_F(URLRequestTestHTTP, EmptyHttpUserAgentSettings) {
                 { "echoheader?Accept-Charset", "None" },
                 { "echoheader?User-Agent", "" } };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) {
+  for (size_t i = 0; i < arraysize(tests); i++) {
     TestDelegate d;
     scoped_ptr<URLRequest> req(context.CreateRequest(
         test_server_.GetURL(tests[i].request), DEFAULT_PRIORITY, &d, NULL));
diff --git a/net/websockets/websocket_frame_parser_test.cc b/net/websockets/websocket_frame_parser_test.cc
index 4eb036d..14f7113 100644
--- a/net/websockets/websocket_frame_parser_test.cc
+++ b/net/websockets/websocket_frame_parser_test.cc
@@ -126,7 +126,7 @@ TEST(WebSocketFrameParserTest, DecodeManyFrames) {
     { "\x81\x05" "Ninth", 7, "Ninth", 5 },
     { "\x81\x05" "Tenth", 7, "Tenth", 5 }
   };
-  static const int kNumInputs = ARRAYSIZE_UNSAFE(kInputs);
+  static const int kNumInputs = arraysize(kInputs);
 
   std::vector<char> input;
   // Concatenate all frames.
@@ -432,7 +432,7 @@ TEST(WebSocketFrameParserTest, InvalidLengthEncoding) {
     { "\x81\x7F\x00\x00\x00\x00\x00\x00\x00\x00", 10 },
     { "\x81\x7E\x00\x00\x00\x00\x00\x00\xFF\xFF", 10 },
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     const char* frame_header = kTests[i].frame_header;
@@ -480,7 +480,7 @@ TEST(WebSocketFrameParserTest, FrameTypes) {
     { "\x8E\x00", 2, 0xE },
     { "\x8F\x00", 2, 0xF }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     const char* frame_header = kTests[i].frame_header;
@@ -533,7 +533,7 @@ TEST(WebSocketFrameParserTest, FinalBitAndReservedBits) {
     { "\x71\x00", 2, false, true, true, true },
     { "\xF1\x00", 2, true, true, true, true }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     const char* frame_header = kTests[i].frame_header;
diff --git a/net/websockets/websocket_frame_test.cc b/net/websockets/websocket_frame_test.cc
index cd76ccc..104bab5 100644
--- a/net/websockets/websocket_frame_test.cc
+++ b/net/websockets/websocket_frame_test.cc
@@ -31,7 +31,7 @@ TEST(WebSocketFrameHeaderTest, FrameLengths) {
     { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
@@ -51,7 +51,7 @@ TEST(WebSocketFrameHeaderTest, FrameLengths) {
 
 TEST(WebSocketFrameHeaderTest, FrameLengthsWithMasking) {
   static const char kMaskingKey[] = "\xDE\xAD\xBE\xEF";
-  COMPILE_ASSERT(ARRAYSIZE_UNSAFE(kMaskingKey) - 1 ==
+  COMPILE_ASSERT(arraysize(kMaskingKey) - 1 ==
                      WebSocketFrameHeader::kMaskingKeyLength,
                  incorrect_masking_key_size);
 
@@ -70,7 +70,7 @@ TEST(WebSocketFrameHeaderTest, FrameLengthsWithMasking) {
     { "\x81\xFF\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDE\xAD\xBE\xEF", 14,
       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   WebSocketMaskingKey masking_key;
   std::copy(kMaskingKey,
@@ -119,7 +119,7 @@ TEST(WebSocketFrameHeaderTest, FrameOpCodes) {
     { "\x8E\x00", 2, 0xE },
     { "\x8F\x00", 2, 0xF }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(kTests[i].opcode);
@@ -155,7 +155,7 @@ TEST(WebSocketFrameHeaderTest, FinalBitAndReservedBits) {
     { "\x71\x00", 2, false, true, true, true },
     { "\xF1\x00", 2, true, true, true, true }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
@@ -196,7 +196,7 @@ TEST(WebSocketFrameHeaderTest, InsufficientBufferSize) {
     { GG_UINT64_C(0x10000), true, 14u },
     { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true, 14u }
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
@@ -235,7 +235,7 @@ TEST(WebSocketFrameTest, MaskPayload) {
     { "\x00\x00\x00\x00", 0, "FooBar", "FooBar", 6 },
     { "\xFF\xFF\xFF\xFF", 0, "FooBar", "\xB9\x90\x90\xBD\x9E\x8D", 6 },
   };
-  static const int kNumTests = ARRAYSIZE_UNSAFE(kTests);
+  static const int kNumTests = arraysize(kTests);
 
   for (int i = 0; i < kNumTests; ++i) {
     WebSocketMaskingKey masking_key;