Convert ARRAYSIZE_UNSAFE -> arraysize in url/.

url/url_util_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/url_canon.h"
 #include "url/url_canon_stdstring.h"
 #include "url/url_parse.h"
 #include "url/url_test_utils.h"
 #include "url/url_util.h"
 
 namespace url {
 
 TEST(URLUtilTest, FindAndCompareScheme) {
@@ skipping 137 matching lines @@
     {"%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(decode_cases); i++) {
+  for (size_t i = 0; i < arraysize(decode_cases); i++) {
     const char* input = decode_cases[i].input;
     RawCanonOutputT<base::char16> output;
     DecodeURLEscapeSequences(input, strlen(input), &output);
     EXPECT_EQ(decode_cases[i].output,
               test_utils::ConvertUTF16ToUTF8(base::string16(output.data(),
                                                             output.length())));
   }
 
   // Our decode should decode %00
   const char zero_input[] = "%00";
@@ skipping 29 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++) {
     const char* input = encode_cases[i].input;
     RawCanonOutputT<char> buffer;
     EncodeURIComponent(input, strlen(input), &buffer);
     std::string output(buffer.data(), buffer.length());
     EXPECT_EQ(encode_cases[i].output, output);
   }
 }
 
 TEST(URLUtilTest, TestResolveRelativeWithNonStandardBase) {
   // This tests non-standard (in the sense that GIsStandard() == false)
@@ skipping 44 matching lines @@
       // Test resolving a fragment (only) against any kind of base-URL.
     {"about:blank", "#id42", true, "about:blank#id42" },
     {"about:blank", " #id42", true, "about:blank#id42" },
     {"about:blank#oldfrag", "#newfrag", true, "about:blank#newfrag" },
       // A surprising side effect of allowing fragments to resolve against
       // any URL scheme is we might break javascript: URLs by doing so...
     {"javascript:alert('foo#bar')", "#badfrag", true,
       "javascript:alert('foo#badfrag" },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(resolve_non_standard_cases); i++) {
+  for (size_t i = 0; i < arraysize(resolve_non_standard_cases); i++) {
     const ResolveRelativeCase& test_data = resolve_non_standard_cases[i];
     Parsed base_parsed;
     ParsePathURL(test_data.base, strlen(test_data.base), false, &base_parsed);
 
     std::string resolved;
     StdStringCanonOutput output(&resolved);
     Parsed resolved_parsed;
     bool valid = ResolveRelative(test_data.base, strlen(test_data.base),
                                  base_parsed, test_data.rel,
                                  strlen(test_data.rel), NULL, &output,
                                  &resolved_parsed);
     output.Complete();
 
     EXPECT_EQ(test_data.is_valid, valid) << i;
     if (test_data.is_valid && valid)
       EXPECT_EQ(test_data.out, resolved) << i;
   }
 }
 
 }  // namespace url