Convert ARRAYSIZE_UNSAFE -> arraysize in extensions/.

extensions/common/url_pattern_unittest.cc

 // Copyright (c) 2012 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/memory/scoped_ptr.h"
 #include "extensions/common/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
@@ skipping 21 matching lines @@
     { "http://", URLPattern::PARSE_ERROR_EMPTY_HOST },
     { "http:///", URLPattern::PARSE_ERROR_EMPTY_HOST },
     { "http:// /", URLPattern::PARSE_ERROR_EMPTY_HOST },
     { "http://*foo/bar", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
     { "http://foo.*.bar/baz", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
     { "http://fo.*.ba:123/baz", URLPattern::PARSE_ERROR_INVALID_HOST_WILDCARD },
     { "http:/bar", URLPattern::PARSE_ERROR_WRONG_SCHEME_SEPARATOR },
     { "http://bar", URLPattern::PARSE_ERROR_EMPTY_PATH },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kInvalidPatterns); ++i) {
+  for (size_t i = 0; i < arraysize(kInvalidPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kInvalidPatterns[i].expected_result,
               pattern.Parse(kInvalidPatterns[i].pattern))
         << kInvalidPatterns[i].pattern;
   }
 
   {
     // Cannot use a C string, because this contains a null byte.
     std::string null_host("http://\0www/", 12);
     URLPattern pattern(URLPattern::SCHEME_ALL);
@@ skipping 22 matching lines @@
     { "http://foo:80:80/monkey", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
     { "file://foo:1234/bar", URLPattern::PARSE_SUCCESS, "*" },
     { "chrome://foo:1234/bar", URLPattern::PARSE_ERROR_INVALID_PORT, "*" },
 
     // Port-like strings in the path should not trigger a warning.
     { "http://*/:1234", URLPattern::PARSE_SUCCESS, "*" },
     { "http://*.foo/bar:1234", URLPattern::PARSE_SUCCESS, "*" },
     { "http://foo/bar:1234/path", URLPattern::PARSE_SUCCESS, "*" },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestPatterns); ++i) {
+  for (size_t i = 0; i < arraysize(kTestPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kTestPatterns[i].expected_result,
               pattern.Parse(kTestPatterns[i].pattern))
         << "Got unexpected result for URL pattern: "
         << kTestPatterns[i].pattern;
     EXPECT_EQ(kTestPatterns[i].expected_port, pattern.port())
         << "Got unexpected port for URL pattern: " << kTestPatterns[i].pattern;
   }
 }
 
@@ skipping 560 matching lines @@
     { "<all_urls>",
       "<all_urls>",
       true
     },
     { "<all_urls>",
       "http://*/*",
       false
     }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEqualsTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kEqualsTestCases); ++i) {
     std::string message = kEqualsTestCases[i].pattern1;
     message += " ";
     message += kEqualsTestCases[i].pattern2;
 
     URLPattern pattern1(URLPattern::SCHEME_ALL);
     URLPattern pattern2(URLPattern::SCHEME_ALL);
 
     pattern1.Parse(kEqualsTestCases[i].pattern1);
     pattern2.Parse(kEqualsTestCases[i].pattern2);
     EXPECT_EQ(kEqualsTestCases[i].expected_equal, pattern1 == pattern2)
@@ skipping 158 matching lines @@
   EXPECT_TRUE(URLPattern(URLPattern::SCHEME_HTTPS, "https://www.google.com/")
                   .MatchesSingleOrigin());
   EXPECT_FALSE(URLPattern(URLPattern::SCHEME_HTTP,
                           "http://*.google.com/foo/bar").MatchesSingleOrigin());
   EXPECT_TRUE(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/foo/bar")
           .MatchesSingleOrigin());
 }
 
 }  // namespace