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

chrome/tools/profile_reset/jtl_parser_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_parser.h"
 
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 135 matching lines @@
       {"// \"//not a literal//\" // comment", ""},
       {"\"literal\" // \"//not a literal//\" // comment", "\"literal\""},
       {"\"//not a comment//\" // \"//not a literal//\" // comment",
        "\"//not a comment//\""},
       {"\"literal // \"not a literal nor a comment",
        "\"literal // \"notaliteralnoracomment"},
       {"\"literal // \"not a literal nor a comment//\"",
        "\"literal // \"notaliteralnoracomment"}
   };
 
-  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);
     scoped_ptr<JtlParser> parser(
         CreateParserFromVerboseText(cases[i].source_code));
     EXPECT_EQ(cases[i].compacted_source_code, parser->compacted_source());
   }
 }
 
 TEST(JtlParser, MismatchedDoubleQuotesBeforeEndOfLine) {
   struct TestCase {
     const char* source_code;
@@ skipping 12 matching lines @@
       {"\"\"\" // not a comment\n\"", 0},
       {"\"\"\" // \" neither a literal nor a comment\"\n\"", 0},
       {"\"\" // comment\n\"// not a comment", 1},
       {"\" // not a comment\"\n\"// not a comment", 1},
       {"foo(\"bar\");\nfoo(\"mismatched);", 1},
       {"foo(\n\"bar\", \"mismatched);", 1},
       {"foo(\n\"bar\", \"mismatched); //comment", 1},
       {"foo(\n\"bar\", \"mismatched);\ngood(\"bar\")", 1}
   };
 
-  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 compacted_source_code;
     std::vector<size_t> newline_indices;
     size_t error_line_number;
     EXPECT_FALSE(JtlParser::RemoveCommentsAndAllWhitespace(
         cases[i].source_code,
         &compacted_source_code,
         &newline_indices,
         &error_line_number));
     EXPECT_EQ(cases[i].error_line_number, error_line_number);
@@ skipping 18 matching lines @@
       {"foo2().", "foo2", "[]", false},
       {"foo3(true);", "foo3", "[true]", true},
       {"foo4(false).", "foo4", "[false]", false},
       {"foo5(\"bar\").", "foo5", "[\"bar\"]", false},
       {"foo6(\" b a r \").", "foo6", "[\" b a r \"]", false},
       {"foo7(true, \"bar\").", "foo7", "[true,\"bar\"]", false},
       {"foo8(\"bar\", false, true);", "foo8", "[\"bar\",false,true]", true},
       {"foo9(\"bar\", \" b a r \");", "foo9", "[\"bar\",\" b a r \"]", true}
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].expected_name);
     scoped_ptr<JtlParser> parser(
         CreateParserFromVerboseText(cases[i].source_code));
     ExpectNextOperation(parser.get(),
                         cases[i].expected_name,
                         cases[i].expected_args,
                         cases[i].expected_ends_sentence);
     EXPECT_TRUE(parser->HasFinished());
   }
 }
@@ skipping 21 matching lines @@
       {"prev().foo1(\"\");next(true);", "foo1", "[\"\"]", true},
       {"prev().foo2(\" \");next(true);", "foo2", "[\" \"]", true},
       {"prev().foo3(\",\",true);next(true);", "foo3", "[\",\",true]", true},
       {"prev().foo4(\")\",true);next(true);", "foo4", "[\")\",true]", true},
       {"prev().foo5(\";\",true);next(true);", "foo5", "[\";\",true]", true},
       {"prev().foo6(\"/\",true).next(true);", "foo6", "[\"/\",true]", false},
       {"prev().foo7(\"//\",true).next(true);", "foo7", "[\"//\",true]", false},
       {"prev().foo8(\".\",true).next(true);", "foo8", "[\".\",true]", false},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].expected_name);
     scoped_ptr<JtlParser> parser(
         CreateParserFromVerboseText(cases[i].source_code));
     ExpectNextOperation(parser.get(), "prev", "[]", false);
     ExpectNextOperation(parser.get(),
                         cases[i].expected_name,
                         cases[i].expected_args,
                         cases[i].expected_ends_sentence);
     ExpectNextOperation(parser.get(), "next", "[true]", true);
     EXPECT_TRUE(parser->HasFinished());
@@ skipping 17 matching lines @@
       {"bad_quotes1(missing both, true).good();", "bad_quotes1"},
       {"bad_quotes2(true, \"missing one).good(); //\"", "bad_quotes2"},
       {"bad_quotes3(\"too\" \"much\", true).good();", "bad_quotes3"},
       {"bad_missing_separator1", "bad_missing_separator1"},
       {"bad_missing_separator2()good();", "bad_missing_separator2"},
       {"bad_parenthesis1(true.good();", "bad_parenthesis1"},
       {"bad_parenthesis2(true.good());", "bad_parenthesis2"},
       {"bad_parenthesis3).good();", "bad_parenthesis3"}
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].operation_name);
     scoped_ptr<JtlParser> parser(
         CreateParserFromVerboseText(cases[i].source_code));
     ExpectNextOperationToFail(parser.get(), 0, cases[i].operation_name);
   }
 }
 
 TEST(JtlParser, SecondOperationIsIllFormed) {
   struct TestCase {
     const char* source_code;
     const char* bad_operation_name;
   } cases[] = {
       {"\ngood(true,false)\n.bad_args(,);", "bad_args"},
       {"\ngood(true,false)\n.bad_quotes1(missing both, true).good();",
        "bad_quotes1"},
       {"\ngood(true,false)\n.bad_quotes2(\"missing one, true).good(); //\"",
        "bad_quotes2"},
       {"\ngood(true,false)\n.bad_quotes3(\"too\" \"many\", true).good();",
        "bad_quotes3"},
       {"\ngood(true,false)\n.bad_separator1()/good();", "bad_separator1"},
       {"\ngood(true,false)\n.missing_separator1", "missing_separator1"},
       {"\ngood(true,false)\n.missing_separator2()good();",
        "missing_separator2"},
       {"\ngood(true,false)\n.bad_parens1(true.good();", "bad_parens1"},
       {"\ngood(true,false)\n.bad_parens2(true.good());", "bad_parens2"},
       {"\ngood(true,false)\n.bad_parens3).good();", "bad_parens3"}
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     SCOPED_TRACE(cases[i].bad_operation_name);
     scoped_ptr<JtlParser> parser(
         CreateParserFromVerboseText(cases[i].source_code));
     ExpectNextOperation(parser.get(), "good", "[true,false]", false);
     ExpectNextOperationToFail(parser.get(), 2, cases[i].bad_operation_name);
   }
 }
 
 }  // namespace