Convert ARRAYSIZE_UNSAFE -> arraysize.

Source/platform/weborigin/DatabaseIdentifierTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 48 matching lines @@
         {"http", "invalidportnumber.org", -5, "__0"},
         {"http", "%E2%98%83.unicode.com", 80, "http_xn--n3h.unicode.com_0"},
         {"http", String::fromUTF8("\xe2\x98\x83.unicode.com"), 80, "http_xn--n3h.unicode.com_0"},
         {"http", String::fromUTF8("\xf0\x9f\x92\xa9.unicode.com"), 80, "http_xn--ls8h.unicode.com_0"},
         {"file", "", 0, "file__0"},
         {"data", "", 0, "__0"},
         {"about", "blank", 0, "__0"},
         {"non-standard", "foobar.com", 0, "non-standard__0"},
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+    for (size_t i = 0; i < arraysize(cases); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create(cases[i].protocol, cases[i].host, cases[i].port);
         String identifier = createDatabaseIdentifierFromSecurityOrigin(origin.get());
         EXPECT_EQ(cases[i].expectedIdentifier, identifier) << "test case " << origin->toString();
     }
 }
 
 // This tests the encoding of a hostname including every character in the range [\x1f, \x80].
 TEST(DatabaseIdentifierTest, CreateIdentifierAllHostChars)
 {
     struct Case {
@@ skipping 101 matching lines @@
         {"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) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", cases[i].hostname, 80);
         String identifier = createDatabaseIdentifierFromSecurityOrigin(origin.get());
         EXPECT_EQ(cases[i].expected, identifier) << "test case " << i << ": \"" << cases[i].hostname << "\"";
         if (cases[i].shouldRoundTrip) {
             RefPtr<SecurityOrigin> parsedOrigin = createSecurityOriginFromDatabaseIdentifier(identifier);
             EXPECT_EQ(cases[i].hostname.lower(), parsedOrigin->host()) << "test case " << i << ": \"" << cases[i].hostname << "\"";
         }
     }
 
 }
@@ skipping 16 matching lines @@
         {"unknown_google.com_0", "", "", 0, "null", true},
         {"http_nondefaultport.net_8001", "http", "nondefaultport.net", 8001, "http://nondefaultport.net:8001", false},
         {"file__0", "", "", 0, "null", true},
         {"__0", "", "", 0, "null", true},
         {"http_foo_bar_baz.org_0", "http", "foo_bar_baz.org", 0, "http://foo_bar_baz.org", false},
         {"http_xn--n3h.unicode.com_0", "http", "xn--n3h.unicode.com", 0, "http://xn--n3h.unicode.com", false},
         {"http_dot.com_0", "http", "dot.com", 0, "http://dot.com", false},
         {"http_escaped%3Dfun.com_0", "http", "escaped%3dfun.com", 0, "http://escaped%3dfun.com", false},
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(validCases); ++i) {
+    for (size_t i = 0; i < arraysize(validCases); ++i) {
         RefPtr<SecurityOrigin> origin = createSecurityOriginFromDatabaseIdentifier(validCases[i].identifier);
         EXPECT_EQ(validCases[i].expectedProtocol, origin->protocol()) << "test case " << i;
         EXPECT_EQ(validCases[i].expectedHost, origin->host()) << "test case " << i;
         EXPECT_EQ(validCases[i].expectedPort, origin->port()) << "test case " << i;
         EXPECT_EQ(validCases[i].expectedStringRepresentation, origin->toString()) << "test case " << i;
         EXPECT_EQ(validCases[i].expectedUnique, origin->isUnique()) << "test case " << i;
     }
 
     String bogusIdentifiers[] = {
         "", "_", "__",
         String("\x00", 1),
         String("http_\x00_0", 8),
         "ht\x7ctp_badprotocol.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",
         String::fromUTF8("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",
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(bogusIdentifiers); ++i) {
+    for (size_t i = 0; i < arraysize(bogusIdentifiers); ++i) {
         RefPtr<SecurityOrigin> origin = createSecurityOriginFromDatabaseIdentifier(bogusIdentifiers[i]);
         EXPECT_EQ("null", origin->toString()) << "test case " << i;
         EXPECT_EQ(true, origin->isUnique()) << "test case " << i;
     }
 }
 
 } // namespace