Convert ARRAYSIZE_UNSAFE -> arraysize in url/.

url/gurl_unittest.cc

 // Copyright 2013 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 "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/url_canon.h"
 #include "url/url_test_utils.h"
 
-// Some implementations of base/basictypes.h may define ARRAYSIZE.
-// If it's not defined, we define it to the ARRAYSIZE_UNSAFE macro
-// which is in our version of basictypes.h.
-#ifndef ARRAYSIZE
-#define ARRAYSIZE ARRAYSIZE_UNSAFE
-#endif
-
 namespace url {
 
 using test_utils::WStringToUTF16;
 using test_utils::ConvertUTF8ToUTF16;
 
 namespace {
 
 template<typename CHAR>
 void SetupReplacement(
     void (Replacements<CHAR>::*func)(const CHAR*, const Component&),
@@ skipping 198 matching lines @@
     "http://user:pass@google.com",
     "http://google.com:12345",
     "http://google.com/path",
     "http://google.com//path",
     "http://google.com?k=v#fragment",
     "http://user:pass@google.com:12345/path?k=v#fragment",
     "http:/path",
     "http:path",
     "://google.com",
   };
-  for (size_t i = 0; i < ARRAYSIZE(valid_cases); i++) {
+  for (size_t i = 0; i < arraysize(valid_cases); i++) {
     EXPECT_TRUE(GURL(valid_cases[i]).is_valid())
         << "Case: " << valid_cases[i];
   }
 
   const char* invalid_cases[] = {
     "http://?k=v",
     "http:://google.com",
     "http//google.com",
     "http://google.com:12three45",
     "path",
   };
-  for (size_t i = 0; i < ARRAYSIZE(invalid_cases); i++) {
+  for (size_t i = 0; i < arraysize(invalid_cases); i++) {
     EXPECT_FALSE(GURL(invalid_cases[i]).is_valid())
         << "Case: " << invalid_cases[i];
   }
 }
 
 TEST(GURLTest, ExtraSlashesBeforeAuthority) {
   // According to RFC3986, the hier-part for URI with an authority must use only
   // two slashes, GURL intentionally just ignores slashes more than 2 and parses
   // the following part as an authority.
   GURL url("http:///host");
@@ skipping 34 matching lines @@
     {"http://www.google.com/foo#bar", "#com", true, "http://www.google.com/foo#com"},
     {"http://www.google.com/", "Https:images.google.com", true, "https://images.google.com/"},
       // A non-standard base can be replaced with a standard absolute URL.
     {"data:blahblah", "http://google.com/", true, "http://google.com/"},
     {"data:blahblah", "http:google.com", true, "http://google.com/"},
       // Filesystem URLs have different paths to test.
     {"filesystem:http://www.google.com/type/", "foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
     {"filesystem:http://www.google.com/type/", "../foo.html", true, "filesystem:http://www.google.com/type/foo.html"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(resolve_cases); i++) {
+  for (size_t i = 0; i < arraysize(resolve_cases); i++) {
     // 8-bit code path.
     GURL input(resolve_cases[i].base);
     GURL output = input.Resolve(resolve_cases[i].relative);
     EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid()) << i;
     EXPECT_EQ(resolve_cases[i].expected, output.spec()) << i;
     EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
 
     // Wide code path.
     GURL inputw(ConvertUTF8ToUTF16(resolve_cases[i].base));
     GURL outputw =
@@ skipping 11 matching lines @@
   } cases[] = {
     {"http://www.google.com", "http://www.google.com/"},
     {"javascript:window.alert(\"hello,world\");", ""},
     {"http://user:pass@www.google.com:21/blah#baz", "http://www.google.com:21/"},
     {"http://user@www.google.com", "http://www.google.com/"},
     {"http://:pass@www.google.com", "http://www.google.com/"},
     {"http://:@www.google.com", "http://www.google.com/"},
     {"filesystem:http://www.google.com/temp/foo?q#b", "http://www.google.com/"},
     {"filesystem:http://user:pass@google.com:21/blah#baz", "http://google.com:21/"},
   };
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     GURL url(cases[i].input);
     GURL origin = url.GetOrigin();
     EXPECT_EQ(cases[i].expected, origin.spec());
   }
 }
 
 TEST(GURLTest, GetAsReferrer) {
   struct TestCase {
     const char* input;
     const char* expected;
   } cases[] = {
     {"http://www.google.com", "http://www.google.com/"},
     {"http://user:pass@www.google.com:21/blah#baz", "http://www.google.com:21/blah"},
     {"http://user@www.google.com", "http://www.google.com/"},
     {"http://:pass@www.google.com", "http://www.google.com/"},
     {"http://:@www.google.com", "http://www.google.com/"},
     {"http://www.google.com/temp/foo?q#b", "http://www.google.com/temp/foo?q"},
   };
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     GURL url(cases[i].input);
     GURL origin = url.GetAsReferrer();
     EXPECT_EQ(cases[i].expected, origin.spec());
   }
 }
 
 TEST(GURLTest, GetWithEmptyPath) {
   struct TestCase {
     const char* input;
     const char* expected;
   } cases[] = {
     {"http://www.google.com", "http://www.google.com/"},
     {"javascript:window.alert(\"hello, world\");", ""},
     {"http://www.google.com/foo/bar.html?baz=22", "http://www.google.com/"},
     {"filesystem:http://www.google.com/temporary/bar.html?baz=22", "filesystem:http://www.google.com/temporary/"},
     {"filesystem:file:///temporary/bar.html?baz=22", "filesystem:file:///temporary/"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     GURL url(cases[i].input);
     GURL empty_path = url.GetWithEmptyPath();
     EXPECT_EQ(cases[i].expected, empty_path.spec());
   }
 }
 
 TEST(GURLTest, Replacements) {
   // The url canonicalizer replacement test will handle most of these case.
   // The most important thing to do here is to check that the proper
   // canonicalizer gets called based on the scheme of the input.
@@ skipping 11 matching lines @@
   } replace_cases[] = {
     {"http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "http://www.google.com/"},
     {"http://www.google.com/foo/bar.html?foo#bar", "javascript", "", "", "", "", "window.open('foo');", "", "", "javascript:window.open('foo');"},
     {"file:///C:/foo/bar.txt", "http", NULL, NULL, "www.google.com", "99", "/foo","search", "ref", "http://www.google.com:99/foo?search#ref"},
 #ifdef WIN32
     {"http://www.google.com/foo/bar.html?foo#bar", "file", "", "", "", "", "c:\\", "", "", "file:///C:/"},
 #endif
     {"filesystem:http://www.google.com/foo/bar.html?foo#bar", NULL, NULL, NULL, NULL, NULL, "/", "", "", "filesystem:http://www.google.com/foo/"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(replace_cases); i++) {
+  for (size_t i = 0; i < arraysize(replace_cases); i++) {
     const ReplaceCase& cur = replace_cases[i];
     GURL url(cur.base);
     GURL::Replacements repl;
     SetupReplacement(&GURL::Replacements::SetScheme, &repl, cur.scheme);
     SetupReplacement(&GURL::Replacements::SetUsername, &repl, cur.username);
     SetupReplacement(&GURL::Replacements::SetPassword, &repl, cur.password);
     SetupReplacement(&GURL::Replacements::SetHost, &repl, cur.host);
     SetupReplacement(&GURL::Replacements::SetPort, &repl, cur.port);
     SetupReplacement(&GURL::Replacements::SetPath, &repl, cur.path);
     SetupReplacement(&GURL::Replacements::SetQuery, &repl, cur.query);
@@ skipping 36 matching lines @@
   } cases[] = {
     {"http://www.google.com", "/", NULL},
     {"http://www.google.com/", "/", NULL},
     {"http://www.google.com/foo/bar.html?baz=22", "/foo/bar.html?baz=22", NULL},
     {"http://www.google.com/foo/bar.html#ref", "/foo/bar.html", NULL},
     {"http://www.google.com/foo/bar.html?query#ref", "/foo/bar.html?query", NULL},
     {"filesystem:http://www.google.com/temporary/foo/bar.html?query#ref", "/foo/bar.html?query", "/temporary"},
     {"filesystem:http://www.google.com/temporary/foo/bar.html?query", "/foo/bar.html?query", "/temporary"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     GURL url(cases[i].input);
     std::string path_request = url.PathForRequest();
     EXPECT_EQ(cases[i].expected, path_request);
     EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL);
     if (url.inner_url() && cases[i].inner_expected)
       EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest());
   }
 }
 
 TEST(GURLTest, EffectiveIntPort) {
@@ skipping 27 matching lines @@
 
     // data - no port
     {"data:www.google.com:90", PORT_UNSPECIFIED},
     {"data:www.google.com", PORT_UNSPECIFIED},
 
     // filesystem - no port
     {"filesystem:http://www.google.com:90/t/foo", PORT_UNSPECIFIED},
     {"filesystem:file:///t/foo", PORT_UNSPECIFIED},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(port_tests); i++) {
+  for (size_t i = 0; i < arraysize(port_tests); i++) {
     GURL url(port_tests[i].spec);
     EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort());
   }
 }
 
 TEST(GURLTest, IPAddress) {
   struct IPTest {
     const char* spec;
     bool expected_ip;
   } ip_tests[] = {
     {"http://www.google.com/", false},
     {"http://192.168.9.1/", true},
     {"http://192.168.9.1.2/", false},
     {"http://192.168.m.1/", false},
     {"http://2001:db8::1/", false},
     {"http://[2001:db8::1]/", true},
     {"", false},
     {"some random input!", false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(ip_tests); i++) {
+  for (size_t i = 0; i < arraysize(ip_tests); i++) {
     GURL url(ip_tests[i].spec);
     EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
   }
 }
 
 TEST(GURLTest, HostNoBrackets) {
   struct TestCase {
     const char* input;
     const char* expected_host;
     const char* expected_plainhost;
   } cases[] = {
     {"http://www.google.com", "www.google.com", "www.google.com"},
     {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"},
     {"http://[::]/", "[::]", "::"},
 
     // Don't require a valid URL, but don't crash either.
     {"http://[]/", "[]", ""},
     {"http://[x]/", "[x]", "x"},
     {"http://[x/", "[x", "[x"},
     {"http://x]/", "x]", "x]"},
     {"http://[/", "[", "["},
     {"http://]/", "]", "]"},
     {"", "", ""},
   };
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     GURL url(cases[i].input);
     EXPECT_EQ(cases[i].expected_host, url.host());
     EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
   }
 }
 
 TEST(GURLTest, DomainIs) {
   const char google_domain[] = "google.com";
 
   GURL url_1("http://www.google.com:99/foo");
@@ skipping 69 matching lines @@
   EXPECT_FALSE(GURL("http://bar/").SchemeIsWSOrWSS());
 }
 
 TEST(GURLTest, SchemeIsBlob) {
   EXPECT_TRUE(GURL("BLOB://BAR/").SchemeIsBlob());
   EXPECT_TRUE(GURL("blob://bar/").SchemeIsBlob());
   EXPECT_FALSE(GURL("http://bar/").SchemeIsBlob());
 }
 
 }  // namespace url