Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/browser/.

chrome/browser/autocomplete/history_url_provider_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 "chrome/browser/autocomplete/history_url_provider.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 430 matching lines @@
   // the results to be in A,B,C order. Note also that our visit counts are
   // all high enough so that domain synthesizing won't get triggered.
   struct TestCase {
     const char* url;
     int count;
   } test_cases[] = {
     {"http://redirects/A", 30},
     {"http://redirects/B", 20},
     {"http://redirects/C", 10}
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     history_service_->AddPageWithDetails(GURL(test_cases[i].url),
         ASCIIToUTF16("Title"), test_cases[i].count, test_cases[i].count,
         Time::Now(), false, history::SOURCE_BROWSED);
   }
 
   // Create a B->C->A redirect chain, but set the visit counts such that they
   // will appear in A,B,C order in the results. The autocomplete query will
   // search for the most recent visit when looking for redirects, so this will
   // be found even though the previous visits had no redirects.
   history::RedirectList redirects_to_a;
@@ skipping 188 matching lines @@
   } test_cases[] = {
     { "fooey", 0 },
     { "fooey/", 1200 },     // 1200 for URL would still navigate by default.
     { "fooey/a", 1200 },    // 1200 for UNKNOWN would not.
     { "fooey/a b", 1200 },  // Also UNKNOWN.
     { "gooey", 1410 },
     { "gooey/", 1410 },
     { "gooey/a", 1400 },
     { "gooey/a b", 1400 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SCOPED_TRACE(test_cases[i].input);
     if (test_cases[i].relevance == 0) {
       RunTest(ASCIIToUTF16(test_cases[i].input), std::string(), false, NULL, 0);
     } else {
       const UrlAndLegalDefault output[] = {
           {url_fixer::FixupURL(test_cases[i].input, std::string()).spec(),
            true}};
       ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16(test_cases[i].input),
                               std::string(), false, output, arraysize(output)));
       // Actual relevance should be at least what test_cases expects and
@@ skipping 108 matching lines @@
   // the results to be in A,B,C order. Note also that our visit counts are
   // all high enough so that domain synthesizing won't get triggered.
   struct TestCase {
     const char* url;
     int count;
   } test_cases[] = {
     {"https://testsearch.com/", 30},
     {"https://testsearch.com/?q=foobar", 20},
     {"http://foobar.com/", 10}
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     history_service_->AddPageWithDetails(GURL(test_cases[i].url),
         base::UTF8ToUTF16("Title"), test_cases[i].count, test_cases[i].count,
         Time::Now(), false, history::SOURCE_BROWSED);
   }
 
   // We should not see search URLs when typing a previously used query.
   const UrlAndLegalDefault expected_when_searching_query[] = {
     { test_cases[2].url, false }
   };
   RunTest(ASCIIToUTF16("foobar"), std::string(), true,
@@ skipping 57 matching lines @@
       "http://w.com", {0, npos, npos}, npos },
     { "    http:////////www.w.com", false,
       "http://www.w.com", {0, npos, npos}, npos },
     { "http:a///www.w.com", false,
       "http://a///www.w.com", {0, npos, npos}, npos },
     { "mailto://a@b.com", true,
       "mailto://a@b.com", {0, npos, npos}, 0 },
     { "mailto://a@b.com", false,
       "mailto://a@b.com", {0, npos, npos}, 0 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Index " << i << " input: "
                                     << test_cases[i].input << ", trim_http: "
                                     << test_cases[i].trim_http);
 
     AutocompleteInput input(ASCIIToUTF16(test_cases[i].input),
                             base::string16::npos, std::string(),
                             GURL("about:blank"),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, true, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
@@ skipping 76 matching lines @@
     { "7.com/1", max_1100_with_time_decay_and_max_cap,
       {{"7.com/1a", 1413, 1413}, {NULL, 0, 0}, {NULL, 0, 0}} },
     { "7.com/4", max_1100_with_time_decay_and_max_cap,
       {{"7.com/4", 1203, 1203}, {"7.com/4a", 1202, 200},
        {"7.com/4b", 1201, 100}} },
 
     // Max relevance cap is 1400 and half-life is 16 days for both visit/typed.
     { "7.com/5", max_1100_visit_typed_decays,
       {{"7.com/5", 1203, 1203}, {"7.com/5a", 1202, 50}, {NULL, 0, 0}} },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SCOPED_TRACE(test_cases[i].input);
     UrlAndLegalDefault output[kMaxMatches];
     int max_matches;
     for (max_matches = 0; max_matches < kMaxMatches; ++max_matches) {
       if (test_cases[i].matches[max_matches].url == NULL)
         break;
       output[max_matches].url =
           url_fixer::FixupURL(test_cases[i].matches[max_matches].url,
                               std::string()).spec();
       output[max_matches].allowed_to_be_default_match = true;
@@ skipping 12 matching lines @@
     // Test the experiment (scoring enabled).
     autocomplete_->scoring_params_.experimental_scoring_enabled = true;
     ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16(test_cases[i].input),
                                     std::string(), false, output, max_matches));
     for (int j = 0; j < max_matches; ++j) {
       EXPECT_EQ(test_cases[i].matches[j].experiment_relevance,
                 matches_[j].relevance);
     }
   }
 }