Convert ARRAYSIZE_UNSAFE -> arraysize in components/.

components/bookmarks/browser/bookmark_index_unittest.cc

 // Copyright 2014 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/bookmarks/browser/bookmark_index.h"
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 155 matching lines @@
 
     // Title with term multiple times.
     { "ab ab",                      "ab",       "ab ab"},
 
     // Make sure quotes don't do a prefix match.
     { "think",                      "\"thi\"",  ""},
 
     // Prefix matches against multiple candidates.
     { "abc1 abc2 abc3 abc4", "abc", "abc1 abc2 abc3 abc4"},
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
+  for (size_t i = 0; i < arraysize(data); ++i) {
     std::vector<std::string> titles;
     base::SplitString(data[i].titles, ';', &titles);
     std::vector<TitleAndURL> bookmarks;
     for (size_t j = 0; j < titles.size(); ++j) {
       TitleAndURL bookmark(titles[j], kAboutBlankURL);
       bookmarks.push_back(bookmark);
     }
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
@@ skipping 43 matching lines @@
     { "foo bar", "Baz Bar",      "http://blah.com/foo",         true  },
     { "foo bar", "Baz Barly",    "http://blah.com/foodie",      true  },
     { "foo bar", "Baz Bur",      "http://blah.com/foo/bar",     true  },
     { "foo bar", "Baz Bur",      "http://blah.com/food/barly",  true  },
     { "foo bar", "Baz Bur",      "http://bar.com/blah/foo",     true  },
     { "foo bar", "Baz Bur",      "http://barly.com/blah/food",  true  },
     { "foo bar", "Baz Bur",      "http://bar.com/blah/flub",    false },
     { "foo bar", "Baz Bur",      "http://foo.com/blah/flub",    false }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
+  for (size_t i = 0; i < arraysize(data); ++i) {
     model_ = client_.CreateModel();
     std::vector<TitleAndURL> bookmarks;
     bookmarks.push_back(TitleAndURL(data[i].title, data[i].url));
     AddBookmarks(bookmarks);
 
     std::vector<std::string> expected;
     if (data[i].should_be_retrieved)
       expected.push_back(data[i].title);
 
     ExpectMatches(data[i].query, expected);
@@ skipping 12 matching lines @@
     { "fooa\xcc\x88-test", "foo" },
     { "foo\xc3\xa4-test", "foo\xc3\xa4-test" },
     { "foo\xc3\xa4-test", "fooa\xcc\x88-test" },
     { "foo\xc3\xa4-test", "foo\xc3\xa4" },
     { "foo\xc3\xa4-test", "fooa\xcc\x88" },
     { "foo\xc3\xa4-test", "foo" },
     { "foo", "foo" }
   };
 
   GURL url(kAboutBlankURL);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
+  for (size_t i = 0; i < arraysize(data); ++i) {
     model_->AddURL(model_->other_node(), 0, UTF8ToUTF16(data[i].title), url);
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 10, &matches);
     EXPECT_EQ(1u, matches.size());
     model_ = client_.CreateModel();
   }
 }
 
 // Makes sure match positions are updated appropriately for title matches.
 TEST_F(BookmarkIndexTest, MatchPositionsTitles) {
   struct TestData {
     const std::string title;
     const std::string query;
     const std::string expected_title_match_positions;
   } data[] = {
     // Trivial test case of only one term, exact match.
     { "a",                        "A",        "0,1" },
     { "foo bar",                  "bar",      "4,7" },
     { "fooey bark",               "bar foo",  "0,3:6,9" },
     // Non-trivial tests.
     { "foobar foo",               "foobar foo",   "0,6:7,10" },
     { "foobar foo",               "foo foobar",   "0,6:7,10" },
     { "foobar foobar",            "foobar foo",   "0,6:7,13" },
     { "foobar foobar",            "foo foobar",   "0,6:7,13" },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
+  for (size_t i = 0; i < arraysize(data); ++i) {
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark(data[i].title, kAboutBlankURL);
     bookmarks.push_back(bookmark);
     AddBookmarks(bookmarks);
 
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(ASCIIToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size());
 
     BookmarkMatch::MatchPositions expected_title_matches;
@@ skipping 30 matching lines @@
     { "http www",   "http://www.foo.com/",               "0,4:7,10"         },
     { "http foo",   "http://www.foo.com/",               "0,4:11,14"        },
     { "http foo",   "http://www.bar.com/baz/foodie/hi",  "0,4:23,26"        },
     { "第二次",      ja_wiki_url,                         "29,56"            },
     { "ja 第二次",   ja_wiki_url,                         "7,9:29,56"        },
     { "第二次 E3.8", ja_wiki_url,                         "29,56:94,98:103,107:"
                                                          "112,116:121,125:"
                                                          "130,134:139,143"  }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
+  for (size_t i = 0; i < arraysize(data); ++i) {
     model_ = client_.CreateModel();
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark("123456", data[i].url);
     bookmarks.push_back(bookmark);
     AddBookmarks(bookmarks);
 
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size()) << data[i].url << data[i].query;
 
     BookmarkMatch::MatchPositions expected_url_matches;
     ExtractMatchPositions(data[i].expected_url_match_positions,
                           &expected_url_matches);
     ExpectMatchPositions(matches[0].url_match_positions, expected_url_matches);
   }
 }
 
 // Makes sure index is updated when a node is removed.
 TEST_F(BookmarkIndexTest, Remove) {
   const char* titles[] = { "a", "b" };
   const char* urls[] = {kAboutBlankURL, kAboutBlankURL};
-  AddBookmarks(titles, urls, ARRAYSIZE_UNSAFE(titles));
+  AddBookmarks(titles, urls, arraysize(titles));
 
   // Remove the node and make sure we don't get back any results.
   model_->Remove(model_->other_node(), 0);
   ExpectMatches("A", NULL, 0U);
 }
 
 // Makes sure index is updated when a node's title is changed.
 TEST_F(BookmarkIndexTest, ChangeTitle) {
   const char* titles[] = { "a", "b" };
   const char* urls[] = {kAboutBlankURL, kAboutBlankURL};
-  AddBookmarks(titles, urls, ARRAYSIZE_UNSAFE(titles));
+  AddBookmarks(titles, urls, arraysize(titles));
 
   // Remove the node and make sure we don't get back any results.
   const char* expected[] = { "blah" };
   model_->SetTitle(model_->other_node()->GetChild(0), ASCIIToUTF16("blah"));
-  ExpectMatches("BlAh", expected, ARRAYSIZE_UNSAFE(expected));
+  ExpectMatches("BlAh", expected, arraysize(expected));
 }
 
 // Makes sure no more than max queries is returned.
 TEST_F(BookmarkIndexTest, HonorMax) {
   const char* titles[] = { "abcd", "abcde" };
   const char* urls[] = {kAboutBlankURL, kAboutBlankURL};
-  AddBookmarks(titles, urls, ARRAYSIZE_UNSAFE(titles));
+  AddBookmarks(titles, urls, arraysize(titles));
 
   std::vector<BookmarkMatch> matches;
   model_->GetBookmarksMatching(ASCIIToUTF16("ABc"), 1, &matches);
   EXPECT_EQ(1U, matches.size());
 }
 
 // Makes sure if the lower case string of a bookmark title is more characters
 // than the upper case string no match positions are returned.
 TEST_F(BookmarkIndexTest, EmptyMatchOnMultiwideLowercaseString) {
   const BookmarkNode* n1 = model_->AddURL(model_->other_node(), 0,
@@ skipping 13 matching lines @@
     const char* title;
     const int typed_count;
   } data[] = {
     { GURL("http://www.google.com/"),      "Google",           100 },
     { GURL("http://maps.google.com/"),     "Google Maps",       40 },
     { GURL("http://docs.google.com/"),     "Google Docs",       50 },
     { GURL("http://reader.google.com/"),   "Google Reader",     80 },
   };
 
   std::map<GURL, int> typed_count_map;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i)
+  for (size_t i = 0; i < arraysize(data); ++i)
     typed_count_map.insert(std::make_pair(data[i].url, data[i].typed_count));
 
   BookmarkClientMock client(typed_count_map);
   scoped_ptr<BookmarkModel> model = client.CreateModel();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i)
+  for (size_t i = 0; i < arraysize(data); ++i)
     // Populate the BookmarkIndex.
     model->AddURL(
         model->other_node(), i, UTF8ToUTF16(data[i].title), data[i].url);
 
   // Populate match nodes.
   std::vector<BookmarkMatch> matches;
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 4, &matches);
 
   // The resulting order should be:
   // 1. Google (google.com) 100
@@ skipping 10 matching lines @@
   // Select top two matches.
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 2, &matches);
 
   ASSERT_EQ(2, static_cast<int>(matches.size()));
   EXPECT_EQ(data[0].url, matches[0].node->url());
   EXPECT_EQ(data[3].url, matches[1].node->url());
 }
 
 }  // namespace
 }  // namespace bookmarks