Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/browser/.

chrome/browser/profile_resetter/jtl_interpreter_unittest.cc

 // Copyright 2011 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/browser/profile_resetter/jtl_interpreter.h"
 
 #include <numeric>
 
 #include "base/strings/string_util.h"
 #include "base/test/values_test_util.h"
@@ skipping 205 matching lines @@
     { VALUE_TRUE, "{ 'KEY_HASH_1': true }", true },
     { VALUE_FALSE, "{ 'KEY_HASH_1': false }", true },
     { VALUE_TRUE, "{ 'KEY_HASH_1': false }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 'abc' }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 1 }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 1.2 }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': [1] }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_COMPARE_NODE_BOOL(cases[i].expected_value) +
         OP_STORE_BOOL(VAR_HASH_1, VALUE_TRUE),
         cases[i].json);
     EXPECT_EQ(JtlInterpreter::OK, interpreter.result());
     if (cases[i].expected_success) {
       base::ExpectDictBooleanValue(
           true, *interpreter.working_memory(), VAR_HASH_1);
@@ skipping 27 matching lines @@
 
     { GetHash("1"), "{ 'KEY_HASH_1': 1 }", true },
     { GetHash("1"), "{ 'KEY_HASH_1': 'VALUE_HASH_1' }", false },
     { GetHash("1"), "{ 'KEY_HASH_1': true }", false },
     { GetHash("1"), "{ 'KEY_HASH_1': 2 }", false },
     { GetHash("1"), "{ 'KEY_HASH_1': 1.1 }", false },
     { GetHash("1"), "{ 'KEY_HASH_1': [1] }", false },
     { GetHash("1"), "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_COMPARE_NODE_HASH(cases[i].expected_value) +
         OP_STORE_BOOL(VAR_HASH_1, VALUE_TRUE),
         cases[i].json);
     EXPECT_EQ(JtlInterpreter::OK, interpreter.result());
     if (cases[i].expected_success) {
       base::ExpectDictBooleanValue(
           true, *interpreter.working_memory(), VAR_HASH_1);
     } else {
       EXPECT_FALSE(interpreter.working_memory()->HasKey(VAR_HASH_1));
     }
   }
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Negated, Iteration " << i);
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_COMPARE_NODE_HASH_NOT(cases[i].expected_value) +
         OP_STORE_BOOL(VAR_HASH_1, VALUE_TRUE),
         cases[i].json);
     EXPECT_EQ(JtlInterpreter::OK, interpreter.result());
     if (!cases[i].expected_success) {
       base::ExpectDictBooleanValue(
           true, *interpreter.working_memory(), VAR_HASH_1);
@@ skipping 11 matching lines @@
   } cases[] = {
     { true, "{ 'KEY_HASH_1': true }", true },
     { false, "{ 'KEY_HASH_1': false }", true },
     { false, "{ 'KEY_HASH_1': 'abc' }", false },
     { false, "{ 'KEY_HASH_1': 1 }", false },
     { false, "{ 'KEY_HASH_1': 1.2 }", false },
     { false, "{ 'KEY_HASH_1': [1] }", false },
     { false, "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_STORE_NODE_BOOL(VAR_HASH_1) +
         OP_STORE_BOOL(VAR_HASH_2, VALUE_TRUE),
         cases[i].json);
     EXPECT_EQ(JtlInterpreter::OK, interpreter.result());
     if (cases[i].expected_success) {
       base::ExpectDictBooleanValue(
           cases[i].expected_value, *interpreter.working_memory(), VAR_HASH_1);
@@ skipping 25 matching lines @@
     { GetHash("1"), "{ 'KEY_HASH_1': true }", false },
     { GetHash("1.2"), "{ 'KEY_HASH_1': true }", false },
 
     { VALUE_TRUE, "{ 'KEY_HASH_1': 'VALUE_HASH_1' }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 1 }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 1.2 }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': [1] }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     std::string store_op;
     if (cases[i].stored_value == VALUE_TRUE ||
         cases[i].stored_value == VALUE_FALSE)
       store_op = OP_STORE_BOOL(VAR_HASH_1, cases[i].stored_value);
     else if (!cases[i].stored_value.empty())
       store_op = OP_STORE_HASH(VAR_HASH_1, cases[i].stored_value);
     INIT_INTERPRETER(
         store_op +
         OP_NAVIGATE(KEY_HASH_1) +
@@ skipping 18 matching lines @@
   } cases[] = {
     { VALUE_HASH_1, "{ 'KEY_HASH_1': 'VALUE_HASH_1' }", true },
     { VALUE_HASH_2, "{ 'KEY_HASH_1': 'VALUE_HASH_2' }", true },
     { GetHash("1"), "{ 'KEY_HASH_1': 1 }", true },
     { GetHash("1.2"), "{ 'KEY_HASH_1': 1.2 }", true },
     { std::string(), "{ 'KEY_HASH_1': true }", false },
     { std::string(), "{ 'KEY_HASH_1': [1] }", false },
     { std::string(), "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_STORE_NODE_HASH(VAR_HASH_1) +
         OP_STORE_BOOL(VAR_HASH_2, VALUE_TRUE),
         cases[i].json);
     EXPECT_EQ(JtlInterpreter::OK, interpreter.result());
     if (cases[i].expected_success) {
       base::ExpectDictStringValue(
           cases[i].expected_value, *interpreter.working_memory(), VAR_HASH_1);
@@ skipping 45 matching lines @@
     { VALUE_TRUE, "{ 'KEY_HASH_1': 'VALUE_HASH_1' }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 1 }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': 1.3 }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': [1] }", false },
     { VALUE_TRUE, "{ 'KEY_HASH_1': {'a': 'b'} }", false },
 
     { VALUE_TRUE, "{ 'KEY_HASH_1': true }", false },
     { VALUE_FALSE, "{ 'KEY_HASH_1': false }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     std::string store_op;
     if (cases[i].stored_value == VALUE_TRUE ||
         cases[i].stored_value == VALUE_FALSE)
       store_op = OP_STORE_BOOL(VAR_HASH_1, cases[i].stored_value);
     else if (!cases[i].stored_value.empty())
       store_op = OP_STORE_HASH(VAR_HASH_1, cases[i].stored_value);
     INIT_INTERPRETER(
         store_op +
         OP_NAVIGATE(KEY_HASH_1) +
@@ skipping 24 matching lines @@
     { "acd", "{ 'KEY_HASH_1': 'abcdefghijklmnopqrstuvwxyz' }", false },
     { "waaaaaaay_too_long", "{ 'KEY_HASH_1': 'abc' }", false },
 
     { VALUE_HASH_1, "{ 'KEY_HASH_1': true }", false },
     { VALUE_HASH_1, "{ 'KEY_HASH_1': 1 }", false },
     { VALUE_HASH_1, "{ 'KEY_HASH_1': 1.1 }", false },
     { VALUE_HASH_1, "{ 'KEY_HASH_1': [1] }", false },
     { VALUE_HASH_1, "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     std::string pattern = cases[i].pattern;
     uint32 pattern_sum = std::accumulate(
         pattern.begin(), pattern.end(), static_cast<uint32>(0u));
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_COMPARE_NODE_SUBSTRING(GetHash(pattern),
                                   EncodeUint32(pattern.size()),
                                   EncodeUint32(pattern_sum)) +
         OP_STORE_BOOL(VAR_HASH_1, VALUE_TRUE),
@@ skipping 33 matching lines @@
     { std::string(), "{ 'KEY_HASH_1': 'http://127.0.0.1/path' }", false },
     { std::string(), "{ 'KEY_HASH_1': 'file:///C:/bar.html' }", false },
 
     { std::string(), "{ 'KEY_HASH_1': 1 }", false },
     { std::string(), "{ 'KEY_HASH_1': 1.2 }", false },
     { std::string(), "{ 'KEY_HASH_1': true }", false },
     { std::string(), "{ 'KEY_HASH_1': [1] }", false },
     { std::string(), "{ 'KEY_HASH_1': {'a': 'b'} }", false },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Iteration " << i);
     INIT_INTERPRETER(
         OP_NAVIGATE(KEY_HASH_1) +
         OP_STORE_NODE_REGISTERABLE_DOMAIN_HASH(VAR_HASH_1) +
         OP_STORE_BOOL(VAR_HASH_2, VALUE_TRUE),
         cases[i].json);
     EXPECT_EQ(JtlInterpreter::OK, interpreter.result());
     if (cases[i].expected_success) {
       base::ExpectDictStringValue(
           cases[i].expected_value, *interpreter.working_memory(), VAR_HASH_1);
@@ skipping 97 matching lines @@
 TEST(JtlInterpreter, CalculateProgramChecksum) {
   const char kTestSeed[] = "Irrelevant seed value.";
   const char kTestProgram[] = "The quick brown fox jumps over the lazy dog.";
   // This program is invalid, but we are not actually executing it.
   base::DictionaryValue input;
   JtlInterpreter interpreter(kTestSeed, kTestProgram, &input);
   EXPECT_EQ(0xef537f, interpreter.CalculateProgramChecksum());
 }
 
 }  // namespace