Convert ARRAYSIZE_UNSAFE -> arraysize in chrome/browser/.

chrome/browser/autocomplete/bookmark_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/bookmark_provider.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 75 matching lines @@
 }
 
 void BookmarkProviderTest::SetUp() {
   profile_.reset(new TestingProfile());
   DCHECK(profile_.get());
   provider_ = new BookmarkProvider(profile_.get());
   DCHECK(provider_.get());
   provider_->set_bookmark_model_for_testing(model_.get());
 
   const BookmarkNode* other_node = model_->other_node();
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(bookmark_provider_test_data); ++i) {
+  for (size_t i = 0; i < arraysize(bookmark_provider_test_data); ++i) {
     const BookmarksTestInfo& cur(bookmark_provider_test_data[i]);
     const GURL url(cur.url);
     model_->AddURL(other_node, other_node->child_count(),
                    base::ASCIIToUTF16(cur.title), url);
   }
 }
 
 // Structures and functions supporting the BookmarkProviderTest.Positions
 // unit test.
 
@@ skipping 147 matching lines @@
     {"frankly",               1, {{{0, 7}, {8, 15}, {0, 0}}}},
     {"frankly frankly",       1, {{{0, 7}, {8, 15}, {0, 0}}}},
     {"foobar foo",            1, {{{0, 6}, {7, 13}, {0, 0}}}},
     {"foo foobar",            1, {{{0, 6}, {7, 13}, {0, 0}}}},
     // This ensures that leading whitespace in the title is removed.
     {"hello",                 1, {{{0, 5}, {7, 12}, {0, 0}}}},
     // This ensures that empty titles yield empty classifications.
     {"emptytitle",            1, {}},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
+  for (size_t i = 0; i < arraysize(query_data); ++i) {
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     // Validate number of results is as expected.
     EXPECT_LE(matches.size(), query_data[i].match_count)
         << "One or more of the following matches were unexpected:\n"
@@ skipping 60 matching lines @@
     // Ranking of prefix matches with URL boost.
     {"burn worm", 3, {"burning worms #1",    // boosted
                       "worming burns #10",   // boosted but longer title
                       "burning worms #2"}},  // not boosted
     // A query of "worm burn" will have the same results.
     {"worm burn", 3, {"burning worms #1",    // boosted
                       "worming burns #10",   // boosted but longer title
                       "burning worms #2"}},  // not boosted
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
+  for (size_t i = 0; i < arraysize(query_data); ++i) {
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     // Validate number and content of results is as expected.
     for (size_t j = 0; j < std::max(query_data[i].match_count, matches.size());
          ++j) {
@@ skipping 34 matching lines @@
     { "versi", "chrome://version", false, "" },
     { "abou", "chrome://omnibox", false, "" },
     { "about:om", "chrome://omnibox", true, "nibox" }
     // Note: when adding a new URL to this test, be sure to add it to the list
     // of bookmarks at the top of the file as well.  All items in this list
     // need to be in the bookmarks list because BookmarkProvider's
     // TitleMatchToACMatch() has an assertion that verifies the URL is
     // actually bookmarked.
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
+  for (size_t i = 0; i < arraysize(query_data); ++i) {
     const std::string description = "for query=" + query_data[i].query +
         " and url=" + query_data[i].url;
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     const base::string16 fixed_up_input(
         provider_->FixupUserInput(input).second);
     BookmarkNode node(GURL(query_data[i].url));
@@ skipping 23 matching lines @@
     { "foo http",  "http://www.foobar.com",      "0:3,4:1,11:3,14:1"     },
     { "blah",      "blah.com",                   "0:3,4:1"               },
     { "http blah", "http://blah.com",            "0:3,4:1,7:3,11:1"      },
     { "dom",       "www.domain.com/http/",       "0:1,4:3,7:1"           },
     { "dom http",  "http://www.domain.com/http/",
       "0:3,4:1,11:3,14:1,22:3,26:1"                                      },
     { "rep",       "www.repeat.com/1/repeat/2/", "0:1,4:3,7:1,17:3,20:1" },
     { "versi",     "chrome://version",           "0:1,9:3,14:1"          }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
+  for (size_t i = 0; i < arraysize(query_data); ++i) {
     std::string description = "for query=" + query_data[i].query;
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, std::string(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     ASSERT_EQ(1U, matches.size()) << description;
     const AutocompleteMatch& match = matches[0];
@@ skipping 10 matching lines @@
       ASSERT_EQ(2U, chunks.size()) << description;
       size_t offset;
       EXPECT_TRUE(base::StringToSizeT(chunks[0], &offset)) << description;
       EXPECT_EQ(offset, match.contents_class[i].offset) << description;
       int style;
       EXPECT_TRUE(base::StringToInt(chunks[1], &style)) << description;
       EXPECT_EQ(style, match.contents_class[i].style) << description;
     }
   }
 }