Convert ARRAYSIZE_UNSAFE -> arraysize.

Source/platform/weborigin/KURLTest.cpp

 /*
  * Copyright (C) 2010 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 57 matching lines @@
         const char* ref;
         bool hasRef;
     } cases[] = {
         {"http://www.google.com/foo/blah?bar=baz#ref", "http", "www.google.com", 0, "", 0, "blah", "bar=baz", "ref", true},
         {"http://foo.com:1234/foo/bar/", "http", "foo.com", 1234, "", 0, "bar", 0, 0, false},
         {"http://www.google.com?#", "http", "www.google.com", 0, "", 0, 0, "", "", true},
         {"https://me:pass@google.com:23#foo", "https", "google.com", 23, "me", "pass", 0, 0, "foo", true},
         {"javascript:hello!//world", "javascript", "", 0, "", 0, "world", 0, 0, false},
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+    for (size_t i = 0; i < arraysize(cases); i++) {
         // UTF-8
         blink::KURL kurl(blink::ParsedURLString, cases[i].url);
 
         EXPECT_EQ(cases[i].protocol, kurl.protocol());
         EXPECT_EQ(cases[i].host, kurl.host());
         EXPECT_EQ(cases[i].port, kurl.port());
         EXPECT_EQ(cases[i].user, kurl.user());
         EXPECT_EQ(cases[i].pass, kurl.pass());
         EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent());
         EXPECT_EQ(cases[i].query, kurl.query());
@@ skipping 142 matching lines @@
             "", "http://:pass@goo.com:92/a?f#b",
             // pass
             "", "http://goo.com:92/a?f#b",
             // path
             "/", "http://goo.com:92/?f#b",
             // query
             0, "http://goo.com:92/#b"
         },
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+    for (size_t i = 0; i < arraysize(cases); i++) {
         blink::KURL kurl(blink::ParsedURLString, cases[i].url);
 
         kurl.setProtocol(cases[i].protocol);
         EXPECT_STREQ(cases[i].expectedProtocol, kurl.string().utf8().data());
 
         kurl.setHost(cases[i].host);
         EXPECT_STREQ(cases[i].expectedHost, kurl.string().utf8().data());
 
         kurl.setPort(cases[i].port);
         EXPECT_STREQ(cases[i].expectedPort, kurl.string().utf8().data());
@@ skipping 28 matching lines @@
         {"%20%21%22%23%24%25%26%27%28%29%2a%2B%2C%2D%2e%2f/", " !\"#$%&'()*+,-.//"},
         {"%30%31%32%33%34%35%36%37%38%39%3a%3B%3C%3D%3e%3f/", "0123456789:;<=>?/"},
         {"%40%41%42%43%44%45%46%47%48%49%4a%4B%4C%4D%4e%4f/", "@ABCDEFGHIJKLMNO/"},
         {"%50%51%52%53%54%55%56%57%58%59%5a%5B%5C%5D%5e%5f/", "PQRSTUVWXYZ[\\]^_/"},
         {"%60%61%62%63%64%65%66%67%68%69%6a%6B%6C%6D%6e%6f/", "`abcdefghijklmno/"},
         {"%70%71%72%73%74%75%76%77%78%79%7a%7B%7C%7D%7e%7f/", "pqrstuvwxyz{|}~\x7f/"},
           // Test un-UTF-8-ization.
         {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"},
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decodeCases); i++) {
+    for (size_t i = 0; i < arraysize(decodeCases); i++) {
         WTF::String input(decodeCases[i].input);
         WTF::String str = blink::decodeURLEscapeSequences(input);
         EXPECT_STREQ(decodeCases[i].output, str.utf8().data());
     }
 
     // Our decode should decode %00
     WTF::String zero = blink::decodeURLEscapeSequences("%00");
     EXPECT_STRNE("%00", zero.utf8().data());
 
     // Test the error behavior for invalid UTF-8 (we differ from WebKit here).
@@ skipping 23 matching lines @@
         {"@ABCDEFGHIJKLMNO",
           "%40ABCDEFGHIJKLMNO"},
         {"PQRSTUVWXYZ[\\]^_",
           "PQRSTUVWXYZ%5B%5C%5D%5E_"},
         {"`abcdefghijklmno",
           "%60abcdefghijklmno"},
         {"pqrstuvwxyz{|}~\x7f",
           "pqrstuvwxyz%7B%7C%7D~%7F"},
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(encode_cases); i++) {
+    for (size_t i = 0; i < arraysize(encode_cases); i++) {
         WTF::String input(encode_cases[i].input);
         WTF::String expectedOutput(encode_cases[i].output);
         WTF::String output = blink::encodeWithURLEscapeSequences(input);
         EXPECT_EQ(expectedOutput, output);
     }
 
     // Our encode escapes NULLs for safety, so we need to check that too.
     WTF::String input("\x00\x01", 2);
     WTF::String reference("%00%01");
 
@@ skipping 345 matching lines @@
         {"data:text/html;charset=utf-8,<html></html>", ""},
         {"javascript:void(0);", ""},
         {"about:config", ""},
         {"https://www.google.com/", "https://www.google.com/"},
         {"http://me@news.google.com:8888/", "http://news.google.com:8888/"},
         {"http://:pass@news.google.com:8888/foo", "http://news.google.com:8888/foo"},
         {"http://me:pass@news.google.com:8888/", "http://news.google.com:8888/"},
         {"https://www.google.com/a?f#b", "https://www.google.com/a?f"},
     };
 
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(referrerCases); i++) {
+    for (size_t i = 0; i < arraysize(referrerCases); i++) {
         blink::KURL kurl(blink::ParsedURLString, referrerCases[i].input);
         WTF::String referrer = kurl.strippedForUseAsReferrer();
         EXPECT_STREQ(referrerCases[i].output, referrer.utf8().data());
     }
 }
 
 } // namespace