Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/browser/.

chrome/browser/autocomplete/search_provider_unittest.cc

 // Copyright 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 "components/omnibox/search_provider.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 779 matching lines @@
     // With suggested relevance scores in a situation where navsuggest
     // would go first only because verbatim has been demoted.
     { "[\"a\",[\"http://a1.com\", \"a2\"],[],[],"
        "{\"google:suggesttype\":[\"NAVIGATION\", \"QUERY\"],"
         "\"google:suggestrelevance\":[1450, 1400],"
         "\"google:verbatimrelevance\":1350}]",
       { "a1.com", "a2", "a" },
       { "a2", "a", kEmptyMatch } },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     ForcedQueryTestHelper("a", cases[i].json, cases[i].matches_in_default_mode,
                            "regular input with json=" + cases[i].json);
     ForcedQueryTestHelper("?a", cases[i].json,
                           cases[i].matches_in_forced_query_mode,
                           "forced query input with json=" + cases[i].json);
   }
 }
 
 // A multiword search with one visit should not autocomplete until multiple
 // words are typed.
@@ skipping 429 matching lines @@
     { "[\"k a\",[\"k adefault-query\", \"adefault.com\"],[],[],"
       "{\"google:verbatimrelevance\":9700,"
       "\"google:suggesttype\":[\"QUERY\", \"NAVIGATION\"],"
       "\"google:suggestrelevance\":[9900, 9800]}]",
       "[\"a\",[\"akeyword-query\"],[],[],{\"google:suggesttype\":[\"QUERY\"],"
       "\"google:verbatimrelevance\":9500,"
       "\"google:suggestrelevance\":[9600]}]",
       { "akeyword-query", "a", "k a", "adefault.com", "k adefault-query" } }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     // Send the query twice in order to have a synchronous pass after the first
     // response is received.  This is necessary because SearchProvider doesn't
     // allow an asynchronous response to change the default match.
     for (size_t j = 0; j < 2; ++j) {
       QueryForInputAndWaitForFetcherResponses(
           ASCIIToUTF16("k a"), true, cases[i].default_provider_json,
           cases[i].keyword_provider_json);
     }
 
     SCOPED_TRACE(
         "for input with default_provider_json=" +
         cases[i].default_provider_json + " and keyword_provider_json=" +
         cases[i].keyword_provider_json);
     const ACMatches& matches = provider_->matches();
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
+    ASSERT_LE(matches.size(), arraysize(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j)
       EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j]), matches[j].contents);
     // Ensure that no expected matches are missing.
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
+    for (; j < arraysize(cases[i].matches); ++j)
       EXPECT_EQ(std::string(), cases[i].matches[j]);
   }
 }
 
 // Verifies that suggest results with relevance scores are added
 // properly when using the default fetcher.  When adding a new test
 // case to this test, please consider adding it to the tests in
 // KeywordFetcherSuggestRelevance below.
 TEST_F(SearchProviderTest, DefaultFetcherSuggestRelevance) {
   struct {
@@ skipping 203 matching lines @@
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
       { { "a", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
         kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
       { { "a", true }, kEmptyExpectedMatch, kEmptyExpectedMatch,
         kEmptyExpectedMatch, kEmptyExpectedMatch, kEmptyExpectedMatch },
       std::string() },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     // Send the query twice in order to have a synchronous pass after the first
     // response is received.  This is necessary because SearchProvider doesn't
     // allow an asynchronous response to change the default match.
     for (size_t j = 0; j < 2; ++j) {
       QueryForInputAndWaitForFetcherResponses(
           ASCIIToUTF16("a"), false, cases[i].json, std::string());
     }
 
     const std::string description = "for input with json=" + cases[i].json;
-    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].matches),
-                 cases[i].matches, provider_->matches());
+    CheckMatches(description, arraysize(cases[i].matches), cases[i].matches,
+                 provider_->matches());
   }
 }
 
 // Verifies that suggest results with relevance scores are added
 // properly when using the keyword fetcher.  This is similar to the
 // test DefaultFetcherSuggestRelevance above but this uses inputs that
 // trigger keyword suggestions (i.e., "k a" rather than "a") and has
 // different expectations (because now the results are a mix of
 // keyword suggestions and default provider suggestions).  When a new
 // test is added to this TEST_F, please consider if it would be
@@ skipping 400 matching lines @@
         "\"google:suggestrelevance\":[9998, 9997, 9999]}]",
       { { "a3",     true,  true },
         { "a1.com", false, false },
         { "a2.com", false, false },
         { "a",      true,  true },
         { "k a",    false, false },
         kEmptyMatch },
       "3" },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     // Send the query twice in order to have a synchronous pass after the first
     // response is received.  This is necessary because SearchProvider doesn't
     // allow an asynchronous response to change the default match.
     for (size_t j = 0; j < 2; ++j) {
       QueryForInput(ASCIIToUTF16("k a"), false, true);
 
       // Set up a default fetcher with no results.
       net::TestURLFetcher* default_fetcher =
           test_factory_.GetFetcherByID(
               SearchProvider::kDefaultProviderURLFetcherID);
@@ skipping 17 matching lines @@
     SCOPED_TRACE("for input with json=" + cases[i].json);
     const ACMatches& matches = provider_->matches();
     ASSERT_FALSE(matches.empty());
     // Find the first match that's allowed to be the default match and check
     // its inline_autocompletion.
     ACMatches::const_iterator it = FindDefaultMatch(matches);
     ASSERT_NE(matches.end(), it);
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               it->inline_autocompletion);
 
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
+    ASSERT_LE(matches.size(), arraysize(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j].contents),
                 matches[j].contents);
       EXPECT_EQ(cases[i].matches[j].from_keyword,
                 matches[j].keyword == ASCIIToUTF16("k"));
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_default_match,
                 matches[j].allowed_to_be_default_match);
     }
     // Ensure that no expected matches are missing.
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j) {
+    for (; j < arraysize(cases[i].matches); ++j) {
       SCOPED_TRACE(" Case # " + base::IntToString(i));
       EXPECT_EQ(kNotApplicable, cases[i].matches[j].contents);
     }
   }
 }
 
 TEST_F(SearchProviderTest, DontInlineAutocompleteAsynchronously) {
   // This test sends two separate queries, each receiving different JSON
   // replies, and checks that at each stage of processing (receiving first
   // asynchronous response, handling new keystroke synchronously / sending the
@@ skipping 167 matching lines @@
         kEmptyExpectedMatch },
       { { "ab1", true }, { "ab2", true }, { "ab", true },
         kEmptyExpectedMatch },
       "[\"ab\",[\"ab1\", \"ab3\"],[],[],"
        "{\"google:verbatimrelevance\":9000,"
         "\"google:suggestrelevance\":[8000, 9500]}]",
       { { "ab", true }, { "ab3", false }, { "ab1", true },
         kEmptyExpectedMatch } },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     // First, send the query "a" and receive the JSON response |first_json|.
     ClearAllResults();
     QueryForInputAndWaitForFetcherResponses(
         ASCIIToUTF16("a"), false, cases[i].first_json, std::string());
 
     // Verify that the matches after the asynchronous results are as expected.
     std::string description = "first asynchronous response for input with "
         "first_json=" + cases[i].first_json;
-    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].first_async_matches),
+    CheckMatches(description, arraysize(cases[i].first_async_matches),
                  cases[i].first_async_matches, provider_->matches());
 
     // Then, send the query "ab" and check the synchronous matches.
     description = "synchronous response after the first keystroke after input "
         "with first_json=" + cases[i].first_json;
     QueryForInput(ASCIIToUTF16("ab"), false, false);
-    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].sync_matches),
+    CheckMatches(description, arraysize(cases[i].sync_matches),
                  cases[i].sync_matches, provider_->matches());
 
     // Finally, get the provided JSON response, |second_json|, and verify the
     // matches after the second asynchronous response are as expected.
     description = "second asynchronous response after input with first_json=" +
         cases[i].first_json + " and second_json=" + cases[i].second_json;
     net::TestURLFetcher* second_fetcher =
         test_factory_.GetFetcherByID(
             SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(second_fetcher);
     second_fetcher->set_response_code(200);
     second_fetcher->SetResponseString(cases[i].second_json);
     second_fetcher->delegate()->OnURLFetchComplete(second_fetcher);
     RunTillProviderDone();
-    CheckMatches(description, ARRAYSIZE_UNSAFE(cases[i].second_async_matches),
+    CheckMatches(description, arraysize(cases[i].second_async_matches),
                  cases[i].second_async_matches, provider_->matches());
   }
 }
 
 TEST_F(SearchProviderTest, LocalAndRemoteRelevances) {
   // We hardcode the string "term1" below, so ensure that the search term that
   // got added to history already is that string.
   ASSERT_EQ(ASCIIToUTF16("term1"), term1_);
   base::string16 term = term1_.substr(0, term1_.length() - 1);
 
@@ skipping 44 matching lines @@
         "\"google:suggestrelevance\":[1440, 1430, 1420, 1410, 1400, 1390]}]",
       { "term", "a1", "a2", "a3", "a4", "a5" } },
     { term,
       "[\"term\",[\"a1\", \"a2\", \"a3\", \"a4\"],[],[],"
        "{\"google:suggesttype\":[\"QUERY\", \"QUERY\", \"QUERY\", \"QUERY\"],"
         "\"google:verbatimrelevance\":1450,"
         "\"google:suggestrelevance\":[1430, 1410, 1390, 1370]}]",
       { "term", "a1", "a2", "term2", "a3", "a4" } }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     QueryForInputAndWaitForFetcherResponses(
         cases[i].input, false, cases[i].json, std::string());
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
 
     // Ensure no extra matches are present.
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
+    ASSERT_LE(matches.size(), arraysize(cases[i].matches));
 
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j)
       EXPECT_EQ(ASCIIToUTF16(cases[i].matches[j]),
                 matches[j].contents) << description;
     // Ensure that no expected matches are missing.
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j)
+    for (; j < arraysize(cases[i].matches); ++j)
       EXPECT_EQ(kNotApplicable, cases[i].matches[j]) <<
           "Case # " << i << " " << description;
   }
 }
 
 // Verifies suggest relevance behavior for URL input.
 TEST_F(SearchProviderTest, DefaultProviderSuggestRelevanceScoringUrlInput) {
   struct DefaultFetcherUrlInputMatch {
     const std::string match_contents;
     AutocompleteMatch::Type match_type;
@@ skipping 75 matching lines @@
       { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
         { "info",  AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch, kEmptyMatch } },
     { "a.com", "[\"a.com\",[\"info\"],[],[],"
                 "{\"google:suggestrelevance\":[9999]}]",
       { { "a.com", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, true  },
         { "info",  AutocompleteMatchType::SEARCH_SUGGEST,        false },
         kEmptyMatch, kEmptyMatch } },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     // Send the query twice in order to have a synchronous pass after the first
     // response is received.  This is necessary because SearchProvider doesn't
     // allow an asynchronous response to change the default match.
     for (size_t j = 0; j < 2; ++j) {
       QueryForInputAndWaitForFetcherResponses(
           ASCIIToUTF16(cases[i].input), false, cases[i].json, std::string());
     }
 
     SCOPED_TRACE("input=" + cases[i].input + " json=" + cases[i].json);
     size_t j = 0;
     const ACMatches& matches = provider_->matches();
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].output));
+    ASSERT_LE(matches.size(), arraysize(cases[i].output));
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       EXPECT_EQ(ASCIIToUTF16(cases[i].output[j].match_contents),
                 matches[j].contents);
       EXPECT_EQ(cases[i].output[j].match_type, matches[j].type);
       EXPECT_EQ(cases[i].output[j].allowed_to_be_default_match,
                 matches[j].allowed_to_be_default_match);
     }
     // Ensure that no expected matches are missing.
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].output); ++j) {
+    for (; j < arraysize(cases[i].output); ++j) {
       EXPECT_EQ(kNotApplicable, cases[i].output[j].match_contents);
       EXPECT_EQ(AutocompleteMatchType::NUM_TYPES,
                 cases[i].output[j].match_type);
       EXPECT_FALSE(cases[i].output[j].allowed_to_be_default_match);
     }
   }
 }
 
 // A basic test that verifies the field trial triggered parsing logic.
 TEST_F(SearchProviderTest, FieldTrialTriggeredParsing) {
@@ skipping 181 matching lines @@
     { "?http://www.ab",  "http://www.abc.com",
                         "?http://www.abc.com", "c.com",       true, false },
     { "?www.ab",         "http://www.abc.com",
                                "?www.abc.com", "c.com",       true, false },
     { "?ab",             "http://www.abc.com",
                                "?www.abc.com", "c.com",       true, false },
     { "?abc.com",        "http://www.abc.com",
                                "?www.abc.com", std::string(), true, true },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     // First test regular mode.
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
     SearchSuggestionParser::NavigationResult result(
         ChromeAutocompleteSchemeClassifier(&profile_), GURL(cases[i].url),
         AutocompleteMatchType::NAVSUGGEST, base::string16(), std::string(),
         false, 0, false, ASCIIToUTF16(cases[i].input), std::string());
     result.set_received_after_last_keystroke(false);
     AutocompleteMatch match(provider_->NavigationToMatch(result));
     EXPECT_EQ(ASCIIToUTF16(cases[i].inline_autocompletion),
               match.inline_autocompletion);
@@ skipping 115 matching lines @@
       "\"google:suggesttype\":[\"QUERY\",\"ENTITY\"]}]",
       { { "x", "", "", "x", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
         { "xy", "", "", "xy", AutocompleteMatchType::SEARCH_SUGGEST },
         { "xy", "A", "p=v", "xy",
           AutocompleteMatchType::SEARCH_SUGGEST_ENTITY },
         kEmptyMatch,
         kEmptyMatch
       },
     },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     QueryForInputAndWaitForFetcherResponses(
         ASCIIToUTF16(cases[i].input_text), false, cases[i].response_json,
         std::string());
 
     const ACMatches& matches = provider_->matches();
     ASSERT_FALSE(matches.empty());
 
     SCOPED_TRACE("for input with json = " + cases[i].response_json);
 
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
+    ASSERT_LE(matches.size(), arraysize(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       const Match& match = cases[i].matches[j];
       SCOPED_TRACE(" and match index: " + base::IntToString(j));
       EXPECT_EQ(match.contents,
                 base::UTF16ToUTF8(matches[j].contents));
       EXPECT_EQ(match.description,
                 base::UTF16ToUTF8(matches[j].description));
       EXPECT_EQ(match.query_params,
                 matches[j].search_terms_args->suggest_query_params);
       EXPECT_EQ(match.fill_into_edit,
                 base::UTF16ToUTF8(matches[j].fill_into_edit));
       EXPECT_EQ(match.type, matches[j].type);
     }
     // Ensure that no expected matches are missing.
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j) {
+    for (; j < arraysize(cases[i].matches); ++j) {
       SCOPED_TRACE(" and match index: " + base::IntToString(j));
       EXPECT_EQ(cases[i].matches[j].contents, kNotApplicable);
       EXPECT_EQ(cases[i].matches[j].description, kNotApplicable);
       EXPECT_EQ(cases[i].matches[j].query_params, kNotApplicable);
       EXPECT_EQ(cases[i].matches[j].fill_into_edit, kNotApplicable);
       EXPECT_EQ(cases[i].matches[j].type, AutocompleteMatchType::NUM_TYPES);
     }
   }
 }
 #endif  // !defined(OS_WIN)
@@ skipping 78 matching lines @@
       "[\"a\",[\"b\", \"c\"],[],[],{\"google:suggestrelevance\":[1, 2]}]",
       { { "a", false, AutocompleteMatchType::SEARCH_OTHER_ENGINE, true},
         { "k a", false, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED, false },
         { "ab", false, AutocompleteMatchType::SEARCH_SUGGEST, false },
         { "c", false, AutocompleteMatchType::SEARCH_SUGGEST, true },
         { "b", false, AutocompleteMatchType::SEARCH_SUGGEST, true }
       },
     }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     QueryForInputAndWaitForFetcherResponses(
         ASCIIToUTF16(cases[i].input_text),
         cases[i].prefer_keyword_provider_results,
         cases[i].default_provider_response_json,
         cases[i].prefer_keyword_provider_results ?
             cases[i].keyword_provider_response_json : std::string());
 
     const std::string description =
         "for input with json =" + cases[i].default_provider_response_json;
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
     EXPECT_GE(matches[0].relevance, 1300);
 
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
+    ASSERT_LE(matches.size(), arraysize(cases[i].matches));
     // Ensure that the returned matches equal the expectations.
     for (size_t j = 0; j < matches.size(); ++j) {
       SCOPED_TRACE(description);
       EXPECT_EQ(cases[i].matches[j].contents,
                 base::UTF16ToUTF8(matches[j].contents));
       EXPECT_EQ(cases[i].matches[j].allowed_to_be_prefetched,
                 SearchProvider::ShouldPrefetch(matches[j]));
       EXPECT_EQ(cases[i].matches[j].type, matches[j].type);
       EXPECT_EQ(cases[i].matches[j].from_keyword,
                 matches[j].keyword == ASCIIToUTF16("k"));
@@ skipping 62 matching lines @@
       "{\"google:suggesttype\":[\"QUERY\",\"QUERY\"],"
       "\"google:suggestrelevance\":[1, 2]}]",
       { { "a", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
         { "c", AutocompleteMatchType::SEARCH_SUGGEST },
         { "b", AutocompleteMatchType::SEARCH_SUGGEST },
         kEmptyMatch,
       },
     },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+  for (size_t i = 0; i < arraysize(cases); ++i) {
     ClearAllResults();
     QueryForInputAndWaitForFetcherResponses(
         ASCIIToUTF16(cases[i].input_text), false,
         cases[i].default_provider_response_json, std::string());
 
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
     EXPECT_GE(matches[0].relevance, 1300);
 
     SCOPED_TRACE("for case: " + base::IntToString(i));
-    ASSERT_LE(matches.size(), ARRAYSIZE_UNSAFE(cases[i].matches));
+    ASSERT_LE(matches.size(), arraysize(cases[i].matches));
     size_t j = 0;
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
       SCOPED_TRACE("and match: " + base::IntToString(j));
       EXPECT_EQ(cases[i].matches[j].contents,
                 base::UTF16ToUTF8(matches[j].contents));
       EXPECT_EQ(cases[i].matches[j].type, matches[j].type);
     }
-    for (; j < ARRAYSIZE_UNSAFE(cases[i].matches); ++j) {
+    for (; j < arraysize(cases[i].matches); ++j) {
       SCOPED_TRACE("and match: " + base::IntToString(j));
       EXPECT_EQ(cases[i].matches[j].contents, kNotApplicable);
       EXPECT_EQ(cases[i].matches[j].type, AutocompleteMatchType::NUM_TYPES);
     }
   }
 }
 
 // Test that deletion url gets set on an AutocompleteMatch when available for a
 // personalized query or a personalized URL.
 TEST_F(SearchProviderTest, ParseDeletionUrl) {
@@ skipping 65 matching lines @@
          { { "a", "", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED },
            { "ac", "", AutocompleteMatchType::SEARCH_SUGGEST },
            { "ab", "", AutocompleteMatchType::SEARCH_SUGGEST },
            { "www.amazon.com", "",
               AutocompleteMatchType::NAVSUGGEST_PERSONALIZED },
            kEmptyMatch,
          },
        },
      };
 
-     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
+     for (size_t i = 0; i < arraysize(cases); ++i) {
        QueryForInputAndWaitForFetcherResponses(
            ASCIIToUTF16(cases[i].input_text), false, cases[i].response_json,
            std::string());
 
        const ACMatches& matches = provider_->matches();
        ASSERT_FALSE(matches.empty());
 
        SCOPED_TRACE("for input with json = " + cases[i].response_json);
 
        for (size_t j = 0; j < matches.size(); ++j) {
@@ skipping 373 matching lines @@
   EXPECT_EQ(base::ASCIIToUTF16("42"), matches[0].answer_type);
   EXPECT_TRUE(matches[1].answer_contents.empty());
   EXPECT_TRUE(matches[1].answer_type.empty());
   EXPECT_TRUE(matches[2].answer_contents.empty());
   EXPECT_TRUE(matches[2].answer_type.empty());
   EXPECT_TRUE(matches[3].answer_contents.empty());
   EXPECT_TRUE(matches[3].answer_type.empty());
   EXPECT_TRUE(matches[4].answer_contents.empty());
   EXPECT_TRUE(matches[4].answer_type.empty());
 }