Convert ARRAYSIZE_UNSAFE -> arraysize in url/.

url/url_canon_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 <errno.h>
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_parse.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;
 using test_utils::ConvertUTF16ToUTF8;
 
 namespace {
 
 struct ComponentCase {
   const char* input;
@@ skipping 84 matching lines @@
     const char* output;
   } utf_cases[] = {
     // Valid code points.
     {0x24, "\x24"},
     {0xA2, "\xC2\xA2"},
     {0x20AC, "\xE2\x82\xAC"},
     {0x24B62, "\xF0\xA4\xAD\xA2"},
     {0x10FFFF, "\xF4\x8F\xBF\xBF"},
   };
   std::string out_str;
-  for (size_t i = 0; i < ARRAYSIZE(utf_cases); i++) {
+  for (size_t i = 0; i < arraysize(utf_cases); i++) {
     out_str.clear();
     StdStringCanonOutput output(&out_str);
     AppendUTF8Value(utf_cases[i].input, &output);
     output.Complete();
     EXPECT_EQ(utf_cases[i].output, out_str);
   }
 }
 
 #if defined(GTEST_HAS_DEATH_TEST)
 // TODO(mattm): Can't run this in debug mode for now, since the DCHECK will
@@ skipping 38 matching lines @@
       // Character going off the end.
     {"\xe4\xbd\xa0\xe5\xa5", L"\x4f60\xd800", false, "%E4%BD%A0%EF%BF%BD"},
       // ...same with low surrogates with no high surrogate.
     {"\xed\xb0\x80", L"\xdc00", false, "%EF%BF%BD"},
       // Test a UTF-8 encoded surrogate value is marked as invalid.
       // ED A0 80 = U+D800
     {"\xed\xa0\x80", NULL, false, "%EF%BF%BD"},
   };
 
   std::string out_str;
-  for (size_t i = 0; i < ARRAYSIZE(utf_cases); i++) {
+  for (size_t i = 0; i < arraysize(utf_cases); i++) {
     if (utf_cases[i].input8) {
       out_str.clear();
       StdStringCanonOutput output(&out_str);
 
       int input_len = static_cast<int>(strlen(utf_cases[i].input8));
       bool success = true;
       for (int ch = 0; ch < input_len; ch++) {
         success &= AppendUTF8EscapedChar(utf_cases[i].input8, &ch, input_len,
                                          &output);
       }
@@ skipping 696 matching lines @@
     {"http://:foo@host.com/", ":foo@", Component(0, 0), Component(1, 3), true},
     {"http://^ :$\t@host.com/", "%5E%20:$%09@", Component(0, 6), Component(7, 4), true},
     {"http://user:pass@/", "user:pass@", Component(0, 4), Component(5, 4), true},
     {"http://%2540:bar@domain.com/", "%2540:bar@", Component(0, 5), Component(6, 3), true },
 
       // IE7 compatability: old versions allowed backslashes in usernames, but
       // IE7 does not. We disallow it as well.
     {"ftp://me\\mydomain:pass@foo.com/", "", Component(0, -1), Component(0, -1), true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(user_info_cases); i++) {
+  for (size_t i = 0; i < arraysize(user_info_cases); i++) {
     int url_len = static_cast<int>(strlen(user_info_cases[i].input));
     Parsed parsed;
     ParseStandardURL(user_info_cases[i].input, url_len, &parsed);
     Component out_user, out_pass;
     std::string out_str;
     StdStringCanonOutput output1(&out_str);
 
     bool success = CanonicalizeUserInfo(user_info_cases[i].input,
                                         parsed.username,
                                         user_info_cases[i].input,
@@ skipping 48 matching lines @@
       // Invalid input should be copied w/ failure.
     {"as df", 80, ":as%20df", Component(1, 7), false},
     {"-2", 80, ":-2", Component(1, 2), false},
       // Default port should be omitted.
     {"80", 80, "", Component(0, -1), true},
     {"8080", 80, ":8080", Component(1, 4), true},
       // PORT_UNSPECIFIED should mean always keep the port.
     {"80", PORT_UNSPECIFIED, ":80", Component(1, 2), true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(port_cases); i++) {
+  for (size_t i = 0; i < arraysize(port_cases); i++) {
     int url_len = static_cast<int>(strlen(port_cases[i].input));
     Component in_comp(0, url_len);
     Component out_comp;
     std::string out_str;
     StdStringCanonOutput output1(&out_str);
     bool success = CanonicalizePort(port_cases[i].input,
                                     in_comp,
                                     port_cases[i].default_port,
                                     &output1,
                                     &out_comp);
@@ skipping 163 matching lines @@
     {"q=\xe4\xbd\xa0\xe5\xa5\xbd", L"q=\x4f60\x597d", "?q=%E4%BD%A0%E5%A5%BD"},
       // Invalid UTF-8/16 input should be replaced with invalid characters.
     {"q=\xed\xed", L"q=\xd800\xd800", "?q=%EF%BF%BD%EF%BF%BD"},
       // Don't allow < or > because sometimes they are used for XSS if the
       // URL is echoed in content. Firefox does this, IE doesn't.
     {"q=<asdf>", L"q=<asdf>", "?q=%3Casdf%3E"},
       // Escape double quotemarks in the query.
     {"q=\"asdf\"", L"q=\"asdf\"", "?q=%22asdf%22"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(query_cases); i++) {
+  for (size_t i = 0; i < arraysize(query_cases); i++) {
     Component out_comp;
 
     if (query_cases[i].input8) {
       int len = static_cast<int>(strlen(query_cases[i].input8));
       Component in_comp(0, len);
       std::string out_str;
 
       StdStringCanonOutput output(&out_str);
       CanonicalizeQuery(query_cases[i].input8, in_comp, NULL, &output,
                         &out_comp);
@@ skipping 136 matching lines @@
     {"ws://foo:80/", "ws://foo/", true},
     {"ws://foo:81/", "ws://foo:81/", true},
     {"ws://foo:443/", "ws://foo:443/", true},
     {"ws://foo:815/", "ws://foo:815/", true},
     {"wss://foo:80/", "wss://foo:80/", true},
     {"wss://foo:81/", "wss://foo:81/", true},
     {"wss://foo:443/", "wss://foo/", true},
     {"wss://foo:815/", "wss://foo:815/", true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     Parsed parsed;
     ParseStandardURL(cases[i].input, url_len, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     bool success = CanonicalizeStandardURL(
         cases[i].input, url_len, parsed, NULL, &output, &out_parsed);
     output.Complete();
@@ skipping 318 matching lines @@
     {"//", "file:///", true, Component(), Component(7, 1)},
     {"///", "file:///", true, Component(), Component(7, 1)},
     {"///test", "file:///test", true, Component(), Component(7, 5)},
     {"file://test", "file://test/", true, Component(7, 4), Component(11, 1)},
     {"file://localhost",  "file://localhost/", true, Component(7, 9), Component(16, 1)},
     {"file://localhost/", "file://localhost/", true, Component(7, 9), Component(16, 1)},
     {"file://localhost/test", "file://localhost/test", true, Component(7, 9), Component(16, 5)},
 #endif  // _WIN32
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     Parsed parsed;
     ParseFileURL(cases[i].input, url_len, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     bool success = CanonicalizeFileURL(cases[i].input, url_len, parsed, NULL,
                                        &output, &out_parsed);
     output.Complete();
@@ skipping 22 matching lines @@
   } cases[] = {
     {"Filesystem:htTp://www.Foo.com:80/tempoRary", "filesystem:http://www.foo.com/tempoRary/", true},
     {"filesystem:httpS://www.foo.com/temporary/", "filesystem:https://www.foo.com/temporary/", true},
     {"filesystem:http://www.foo.com//", "filesystem:http://www.foo.com//", false},
     {"filesystem:http://www.foo.com/persistent/bob?query#ref", "filesystem:http://www.foo.com/persistent/bob?query#ref", true},
     {"filesystem:fIle://\\temporary/", "filesystem:file:///temporary/", true},
     {"filesystem:fiLe:///temporary", "filesystem:file:///temporary/", true},
     {"filesystem:File:///temporary/Bob?qUery#reF", "filesystem:file:///temporary/Bob?qUery#reF", true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     Parsed parsed;
     ParseFileSystemURL(cases[i].input, url_len, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     bool success = CanonicalizeFileSystemURL(cases[i].input, url_len, parsed,
                                              NULL, &output, &out_parsed);
     output.Complete();
@@ skipping 14 matching lines @@
   // Path URLs should get canonicalized schemes but nothing else.
   struct PathCase {
     const char* input;
     const char* expected;
   } path_cases[] = {
     {"javascript:", "javascript:"},
     {"JavaScript:Foo", "javascript:Foo"},
     {":\":This /is interesting;?#", ":\":This /is interesting;?#"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(path_cases); i++) {
+  for (size_t i = 0; i < arraysize(path_cases); i++) {
     int url_len = static_cast<int>(strlen(path_cases[i].input));
     Parsed parsed;
     ParsePathURL(path_cases[i].input, url_len, true, &parsed);
 
     Parsed out_parsed;
     std::string out_str;
     StdStringCanonOutput output(&out_str);
     bool success = CanonicalizePathURL(path_cases[i].input, url_len, parsed,
                                        &output, &out_parsed);
     output.Complete();
@@ skipping 33 matching lines @@
     {"mailto:addr1\0addr2?foo", "mailto:addr1%00addr2?foo", true, Component(7, 13), Component(21, 3)},
     // Invalid -- UTF-8 encoded surrogate value.
     {"mailto:\xed\xa0\x80", "mailto:%EF%BF%BD", false, Component(7, 9), Component()},
     {"mailto:addr1?", "mailto:addr1?", true, Component(7, 5), Component(13, 0)},
   };
 
   // Define outside of loop to catch bugs where components aren't reset
   Parsed parsed;
   Parsed out_parsed;
 
-  for (size_t i = 0; i < ARRAYSIZE(cases); i++) {
+  for (size_t i = 0; i < arraysize(cases); i++) {
     int url_len = static_cast<int>(strlen(cases[i].input));
     if (i == 8) {
       // The 9th test case purposely has a '\0' in it -- don't count it
       // as the string terminator.
       url_len = 22;
     }
     ParseMailtoURL(cases[i].input, url_len, &parsed);
 
     std::string out_str;
     StdStringCanonOutput output(&out_str);
@@ skipping 242 matching lines @@
     {"filesystem:http://host/t/path", true, false, "http://host/t/path2", true, false, false, NULL},
     {"http://host/t/path", true, false, "filesystem:http://host/t/path2", true, false, false, NULL},
     {"filesystem:http://host/t/path", true, false, "./path2", true, true, true, "filesystem:http://host/t/path2"},
     {"filesystem:http://host/t/path/", true, false, "path2", true, true, true, "filesystem:http://host/t/path/path2"},
     {"filesystem:http://host/t/path", true, false, "filesystem:http:path2", true, false, false, NULL},
       // Absolute URLs are still not relative to a non-standard base URL.
     {"about:blank", false, false, "http://X/A", true, false, true, ""},
     {"about:blank", false, false, "content://content.Provider/", true, false, true, ""},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE(rel_cases); i++) {
+  for (size_t i = 0; i < arraysize(rel_cases); i++) {
     const RelativeCase& cur_case = rel_cases[i];
 
     Parsed parsed;
     int base_len = static_cast<int>(strlen(cur_case.base));
     if (cur_case.is_base_file)
       ParseFileURL(cur_case.base, base_len, &parsed);
     else if (cur_case.is_base_hier)
       ParseStandardURL(cur_case.base, base_len, &parsed);
     else
       ParsePathURL(cur_case.base, base_len, false, &parsed);
@@ skipping 72 matching lines @@
   repl_output.Complete();
 
   // Generate the expected string and check.
   std::string expected("file:///foo?");
   for (size_t i = 0; i < new_query.length(); i++)
     expected.push_back('a');
   EXPECT_TRUE(expected == repl_str);
 }
 
 }  // namespace url