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

chrome/renderer/spellchecker/spellcheck_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/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 360 matching lines @@
     {L"10th", true},
     {L"100th", true},
     {L"1000th", true},
     {L"25", true},
     {L"2012", true},
     {L"100,000,000", true},
     {L"3.141592653", true},
 
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     size_t input_length = 0;
     if (kTestCases[i].input != NULL) {
       input_length = wcslen(kTestCases[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_check()->SpellCheckWord(
         base::WideToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
         0,
@@ skipping 29 matching lines @@
     {L"wate", false, 0, 0, L"ate"},
     {L"jum", false, 0, 0, L"jump"},
     {L"jum", false, 0, 0, L"hum"},
     {L"jum", false, 0, 0, L"sum"},
     {L"jum", false, 0, 0, L"um"},
     // A regression test for Issue 36523.
     {L"privliged", false, 0, 0, L"privileged"},
     // TODO (Sidchat): add many more examples.
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     std::vector<base::string16> suggestions;
     size_t input_length = 0;
     if (kTestCases[i].input != NULL) {
       input_length = wcslen(kTestCases[i].input);
     }
     int misspelling_start;
     int misspelling_length;
     bool result = spell_check()->SpellCheckWord(
         base::WideToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
@@ skipping 358 matching lines @@
       L"\x043c\x0430\x0432\x04b7\x0443\x0434\x0430, \x043e\x0441\x043e\x043d "
       L"\x043d\x0430\x043c\x0443\x0434\x0430\x043d\x0438 "
       L"\x0438\x0441\x0442\x0438\x0444\x043e\x0434\x0430\x0431\x0430\x0440"
       L"\x04e3 \x0432\x0430 \x0434\x0430\x0441\x0442\x0440\x0430\x0441\x0438 "
       L"\x0443\x043c\x0443\x043c "
       L"\x0433\x0430\x0440\x0434\x043e\x043d\x0438\x0434\x0430\x043d\x0438 "
       L"\x043e\x043d\x04b3\x043e \x0430\x0441\x0442."
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     ReinitializeSpellCheck(kTestCases[i].language);
     size_t input_length = 0;
     if (kTestCases[i].input != NULL)
       input_length = wcslen(kTestCases[i].input);
 
     int misspelling_start = 0;
     int misspelling_length = 0;
     bool result = spell_check()->SpellCheckWord(
         base::WideToUTF16(kTestCases[i].input).c_str(),
         static_cast<int>(input_length),
@@ skipping 24 matching lines @@
   } kTestCases[] = {
     {"teh", "the"},
     {"moer", "more"},
     {"watre", "water"},
     {"noen", ""},
     {"what", ""},
   };
 
   EnableAutoCorrect(true);
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     base::string16 misspelled_word(base::UTF8ToUTF16(kTestCases[i].input));
     base::string16 expected_autocorrect_word(
         base::UTF8ToUTF16(kTestCases[i].expected_result));
     base::string16 autocorrect_word = spell_check()->GetAutoCorrectionWord(
         misspelled_word, 0);
 
     // Check for spelling.
     EXPECT_EQ(expected_autocorrect_word, autocorrect_word);
   }
 }
@@ skipping 21 matching lines @@
       // Hindi
       "hi-IN",
       L"\x0905\x0905\x0905\x0905\x0905\x0905\x0905\x0905\x0905\x0905",
     }, {
       // A misspelled word for Russian
       "ru-RU",
       L"\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430\x0430",
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     ReinitializeSpellCheck(kTestCases[i].language);
 
     base::string16 word(base::WideToUTF16(kTestCases[i].input));
     int word_length = static_cast<int>(word.length());
     int misspelling_start = 0;
     int misspelling_length = 0;
     bool result = spell_check()->SpellCheckWord(word.c_str(),
                                                 word_length,
                                                 0,
                                                 &misspelling_start,
@@ skipping 286 matching lines @@
     {"recencies", false},
     // Issue 140486
     {"movie", true},
     {"movies", true},
   };
 
   static const char* kLocales[] = { "en-GB", "en-US", "en-CA", "en-AU" };
 
   for (size_t j = 0; j < arraysize(kLocales); ++j) {
     ReinitializeSpellCheck(kLocales[j]);
-    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+    for (size_t i = 0; i < arraysize(kTestCases); ++i) {
       size_t input_length = 0;
       if (kTestCases[i].input != NULL)
         input_length = strlen(kTestCases[i].input);
 
       int misspelling_start = 0;
       int misspelling_length = 0;
       bool result = spell_check()->SpellCheckWord(
           base::ASCIIToUTF16(kTestCases[i].input).c_str(),
           static_cast<int>(input_length),
           0,
@@ skipping 22 matching lines @@
     {"suckerbert", "cocksuckers", "en-US", true},
     {"suckerbert", "cocksuckers", "en-CA", true},
     {"suckerbert", "cocksuckers", "en-AU", true},
     {"Batasunaa",  "Batasuna",    "ca-ES", true},
     {"pornoo",     "porno",       "it-IT", true},
     {"catass",     "catas",       "lt-LT", true},
     {"kuracc",     "kurac",       "sl-SI", true},
     {"pittt",      "pitt",        "sv-SE", true},
   };
 
-  size_t test_cases_size = ARRAYSIZE_UNSAFE(kTestCases);
+  size_t test_cases_size = arraysize(kTestCases);
   for (size_t i = 0; i < test_cases_size; ++i) {
     ReinitializeSpellCheck(kTestCases[i].locale);
     size_t suggestion_length = 0;
     if (kTestCases[i].suggestion != NULL)
       suggestion_length = strlen(kTestCases[i].suggestion);
 
     // First check that the NOSUGGEST flag didn't mark this word as not being in
     // the dictionary.
     int misspelling_start = 0;
     int misspelling_length = 0;
@@ skipping 73 matching lines @@
   // Initialization magic - call InitializeIfNeeded twice. The first one simply
   // flags internal state that a dictionary was requested. The second one will
   // take the passed-in file and initialize hunspell with it. (The file was
   // passed to hunspell in the ctor for the test fixture).
   // This needs to be done since we need to ensure the SpellingEngine object
   // contained in |spellcheck_| from the test fixture does get initialized.
   // TODO(groby): Clean up this mess.
   InitializeIfNeeded();
   ASSERT_FALSE(InitializeIfNeeded());
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     bool result = CheckSpelling(kTestCases[i].word, 0);
     EXPECT_EQ(kTestCases[i].expected_result, result) <<
         "Failed test for " << kTestCases[i].word;
   }
 }
 
 // Chrome should not suggest "Othello" for "hellllo" or "identically" for
 // "accidently".
 TEST_F(SpellCheckTest, LogicalSuggestions) {
   static const struct {
     const char* misspelled;
     const char* suggestion;
   } kTestCases[] = {
     { "hellllo", "hello" },
     { "accidently", "accidentally" }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     int misspelling_start = 0;
     int misspelling_length = 0;
     std::vector<base::string16> suggestions;
     EXPECT_FALSE(spell_check()->SpellCheckWord(
         base::ASCIIToUTF16(kTestCases[i].misspelled).c_str(),
         strlen(kTestCases[i].misspelled),
         0,
         &misspelling_start,
         &misspelling_length,
         &suggestions));
     EXPECT_GE(suggestions.size(), static_cast<size_t>(1));
     if (suggestions.size() > 0)
       EXPECT_EQ(suggestions[0], base::ASCIIToUTF16(kTestCases[i].suggestion));
   }
 }