Convert ARRAYSIZE_UNSAFE -> arraysize in content/.

content/common/database_identifier_unittest.cc

 // Copyright 2014 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 "storage/common/database/database_identifier.h"
 
 #include "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 17 matching lines @@
     {"http://invalidportnumber.org:-6", "__0"},
     {"http://%E2%98%83.unicode.com", "http_xn--n3h.unicode.com_0"},
     {"http://\xe2\x98\x83.unicode.com", "http_xn--n3h.unicode.com_0"},
     {"http://\xf0\x9f\x92\xa9.unicode.com", "http_xn--ls8h.unicode.com_0"},
     {"file:///", "file__0"},
     {"data:", "__0"},
     {"about:blank", "__0"},
     {"non-standard://foobar.com", "__0"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     GURL origin(cases[i].origin);
     DatabaseIdentifier identifier =
         DatabaseIdentifier::CreateFromOrigin(origin);
     EXPECT_EQ(cases[i].expectedIdentifier, identifier.ToString())
         << "test case " << cases[i].origin;
   }
 }
 
 // This tests the encoding of a hostname including every character in the range
 // [\x1f, \x80].
@@ skipping 96 matching lines @@
     {"x\x79x", "http_xyx_0", true},
     {"x\x7ax", "http_xzx_0", true},
     {"x\x7bx", "http_x%7bx_0", false},
     {"x\x7cx", "http_x%7cx_0", false},
     {"x\x7dx", "http_x%7dx_0", false},
     {"x\x7ex", "__0", false},
     {"x\x7fx", "__0", false},
     {"x\x80x", "__0", false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     GURL origin("http://" + cases[i].hostname);
     DatabaseIdentifier identifier =
         DatabaseIdentifier::CreateFromOrigin(origin);
     EXPECT_EQ(cases[i].expected, identifier.ToString())
         << "test case " << i << " :\"" << cases[i].hostname << "\"";
     if (cases[i].shouldRoundTrip) {
       DatabaseIdentifier parsed_identifier =
           DatabaseIdentifier::Parse(identifier.ToString());
       EXPECT_EQ(identifier.ToString(), parsed_identifier.ToString())
           << "test case " << i << " :\"" << cases[i].hostname << "\"";
@@ skipping 30 matching lines @@
     {"http_foo_bar_baz.org_0",
      "http", "foo_bar_baz.org", 0, GURL("http://foo_bar_baz.org"), false},
     {"http_xn--n3h.unicode.com_0",
      "http", "xn--n3h.unicode.com", 0,
       GURL("http://xn--n3h.unicode.com"), false},
     {"http_dot.com_0", "http", "dot.com", 0, GURL("http://dot.com"), false},
     {"http_escaped%3Dfun.com_0", "http", "escaped%3dfun.com", 0,
       GURL("http://escaped%3dfun.com"), false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(valid_cases); ++i) {
+  for (size_t i = 0; i < arraysize(valid_cases); ++i) {
     DatabaseIdentifier identifier =
         DatabaseIdentifier::Parse(valid_cases[i].str);
     EXPECT_EQ(valid_cases[i].expected_scheme, identifier.scheme())
         << "test case " << valid_cases[i].str;
     EXPECT_EQ(valid_cases[i].expected_host, identifier.hostname())
         << "test case " << valid_cases[i].str;
     EXPECT_EQ(valid_cases[i].expected_port, identifier.port())
         << "test case " << valid_cases[i].str;
     EXPECT_EQ(valid_cases[i].expected_origin, identifier.ToOrigin())
         << "test case " << valid_cases[i].str;
     EXPECT_EQ(valid_cases[i].expected_unique, identifier.is_unique())
         << "test case " << valid_cases[i].str;
   }
 
   std::string bogus_components[] = {
     "", "_", "__", std::string("\x00", 1), std::string("http_\x00_0", 8),
     "ht\x7ctp_badscheme.com_0", "http_unescaped_percent_%.com_0",
     "http_port_too_big.net_75000", "http_port_too_small.net_-25",
     "http_shouldbeescaped\x7c.com_0", "http_latin1\x8a.org_8001",
     "http_\xe2\x98\x83.unicode.com_0",
     "http_dot%252ecom_0",
     "HtTp_NonCanonicalRepresenTation_0",
     "http_non_ascii.\xa1.com_0",
     "http_not_canonical_escape%3d_0",
     "http_bytes_after_port_0abcd",
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(bogus_components); ++i) {
+  for (size_t i = 0; i < arraysize(bogus_components); ++i) {
     DatabaseIdentifier identifier =
         DatabaseIdentifier::Parse(bogus_components[i]);
     EXPECT_EQ("__0", identifier.ToString())
         << "test case " << bogus_components[i];
     EXPECT_EQ(GURL("null"), identifier.ToOrigin())
         << "test case " << bogus_components[i];
     EXPECT_EQ(true, identifier.is_unique())
         << "test case " << bogus_components[i];
   }
 }
 
 }  // namespace
 }  // namespace content