Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/, outside of chrome/browser/.

chrome/tools/profile_reset/jtl_compiler_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 "chrome/tools/profile_reset/jtl_compiler.h"
 
 #include <string>
 
 #include "base/values.h"
 #include "chrome/browser/profile_resetter/jtl_foundation.h"
@@ skipping 58 matching lines @@
         {"compare_to_stored_bool(\"name\").",
          OP_COMPARE_NODE_TO_STORED_BOOL(GetHash("name"))},
         {"compare_to_stored_hash(\"name\").",
          OP_COMPARE_NODE_TO_STORED_HASH(GetHash("name"))},
         {"compare_substring_hashed(\"pattern\").",
          OP_COMPARE_NODE_SUBSTRING(
              GetHash("pattern"), EncodeUint32(7), EncodeUint32(766))},
         {"break.", OP_STOP_EXECUTING_SENTENCE},
         {"break;", OP_STOP_EXECUTING_SENTENCE + OP_END_OF_SENTENCE}};
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].source_code);
     std::string bytecode;
     EXPECT_TRUE(JtlCompiler::Compile(
         cases[i].source_code, kTestHashSeed, &bytecode, NULL));
     EXPECT_EQ(cases[i].expected_bytecode, bytecode);
   }
 }
 
 TEST(JtlCompiler, CompileEntireProgram) {
   const char kSourceCode[] =
@@ skipping 27 matching lines @@
   EXPECT_EQ(2u, error.line_number);
   EXPECT_EQ(JtlCompiler::CompileError::INVALID_OPERATION_NAME,
             error.error_code);
 }
 
 TEST(JtlCompiler, InvalidArgumentsCount) {
   const char* kSourceCodes[] = {
       "any().\nstore_bool(\"name\", true, \"superfluous argument\");\n",
       "any().\nstore_bool(\"name\");"};  // missing argument
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSourceCodes); ++i) {
+  for (size_t i = 0; i < arraysize(kSourceCodes); ++i) {
     SCOPED_TRACE(kSourceCodes[i]);
     std::string bytecode;
     JtlCompiler::CompileError error;
     EXPECT_FALSE(JtlCompiler::Compile(
         kSourceCodes[i], kTestHashSeed, &bytecode, &error));
     EXPECT_THAT(error.context, testing::StartsWith("store_bool"));
     EXPECT_EQ(1u, error.line_number);
     EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_COUNT,
               error.error_code);
   }
@@ skipping 10 matching lines @@
         {"compare_hashed", "any()\n.\ncompare_hashed(false);"},
         {"store_hash", "any()\n.\nstore_hash(\"name\", false);"},
         {"store_hash", "any()\n.\nstore_hash(\"name\", \"foo\");"},
         {"compare_stored_bool",
          "any()\n.\ncompare_stored_bool(\"name\", \"need a bool\", false);"},
         {"compare_stored_bool",
          "any()\n.\ncompare_stored_bool(\"name\", false, \"need a bool\");"},
         {"compare_substring_hashed",
          "any()\n.\ncompare_substring_hashed(true);"}};
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].source_code);
     std::string bytecode;
     JtlCompiler::CompileError error;
     EXPECT_FALSE(JtlCompiler::Compile(
         cases[i].source_code, kTestHashSeed, &bytecode, &error));
     EXPECT_THAT(error.context,
                 testing::StartsWith(cases[i].expected_context_prefix));
     EXPECT_EQ(2u, error.line_number);
     EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_TYPE,
               error.error_code);
   }
 }
 
 TEST(JtlCompiler, InvalidArgumentValue) {
   struct TestCase {
     std::string expected_context_prefix;
     std::string source_code;
   } cases[] = {
         {"compare_substring_hashed", "compare_substring_hashed(\"\");"}};
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].source_code);
     std::string bytecode;
     JtlCompiler::CompileError error;
     EXPECT_FALSE(JtlCompiler::Compile(
         cases[i].source_code, kTestHashSeed, &bytecode, &error));
     EXPECT_THAT(error.context,
                 testing::StartsWith(cases[i].expected_context_prefix));
     EXPECT_EQ(0u, error.line_number);
     EXPECT_EQ(JtlCompiler::CompileError::INVALID_ARGUMENT_VALUE,
               error.error_code);
@@ skipping 18 matching lines @@
   std::string bytecode;
   JtlCompiler::CompileError error;
   EXPECT_FALSE(
       JtlCompiler::Compile(kSourceCode, kTestHashSeed, &bytecode, &error));
   EXPECT_THAT(error.context, testing::StartsWith("go"));
   EXPECT_EQ(1u, error.line_number);
   EXPECT_EQ(JtlCompiler::CompileError::PARSING_ERROR, error.error_code);
 }
 
 }  // namespace