Convert ARRAYSIZE_UNSAFE -> arraysize in components/.

components/search_engines/template_url_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 "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
@@ skipping 44 matching lines @@
   } search_term_cases[] = {
     { "http://foo{searchTerms}", ASCIIToUTF16("sea rch/bar"),
       "http://foosea%20rch/bar" },
     { "http://foo{searchTerms}?boo=abc", ASCIIToUTF16("sea rch/bar"),
       "http://foosea%20rch/bar?boo=abc" },
     { "http://foo/?boo={searchTerms}", ASCIIToUTF16("sea rch/bar"),
       "http://foo/?boo=sea+rch%2Fbar" },
     { "http://en.wikipedia.org/{searchTerms}", ASCIIToUTF16("wiki/?"),
       "http://en.wikipedia.org/wiki/%3F" }
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
+  for (size_t i = 0; i < arraysize(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     TemplateURLData data;
     data.SetURL(value.url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
@@ skipping 220 matching lines @@
     const char* output;
   } search_term_cases[] = {
     { "{google:baseURL}{language}{searchTerms}", base::string16(),
       "http://example.com/e/en" },
     { "{google:baseSuggestURL}{searchTerms}", base::string16(),
       "http://example.com/complete/" }
   };
 
   TestingSearchTermsData search_terms_data("http://example.com/e/");
   TemplateURLData data;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(search_term_cases); ++i) {
+  for (size_t i = 0; i < arraysize(search_term_cases); ++i) {
     const SearchTermsCase& value = search_term_cases[i];
     data.SetURL(value.url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data));
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(value.terms), search_terms_data, NULL));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(value.output, result.spec());
   }
@@ skipping 20 matching lines @@
     {"C%252B", ASCIIToUTF16("C%2B")},
   };
 
   // Set one input encoding: big-5. This is so we can test fallback to UTF-8.
   TemplateURLData data;
   data.SetURL("http://foo?q={searchTerms}");
   data.input_encodings.push_back("big-5");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(to_wide_cases); i++) {
+  for (size_t i = 0; i < arraysize(to_wide_cases); i++) {
     EXPECT_EQ(to_wide_cases[i].expected_decoded_term,
               url.url_ref().SearchTermToString16(
                   to_wide_cases[i].encoded_search_term));
   }
 }
 
 TEST_F(TemplateURLTest, DisplayURLToURLRef) {
   struct TestData {
     const std::string url;
     const base::string16 expected_result;
   } test_data[] = {
     { "http://foo{searchTerms}x{inputEncoding}y{outputEncoding}a",
       ASCIIToUTF16("http://foo%sx{inputEncoding}y{outputEncoding}a") },
     { "http://X",
       ASCIIToUTF16("http://X") },
     { "http://foo{searchTerms",
       ASCIIToUTF16("http://foo{searchTerms") },
     { "http://foo{searchTerms}{language}",
       ASCIIToUTF16("http://foo%s{language}") },
   };
   TemplateURLData data;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_EQ(test_data[i].expected_result,
               url.url_ref().DisplayURL(search_terms_data_));
     EXPECT_EQ(test_data[i].url,
               TemplateURLRef::DisplayURLToURLRef(
                   url.url_ref().DisplayURL(search_terms_data_)));
   }
 }
 
@@ skipping 22 matching lines @@
       "http://foo/Xa{language}aUTF-8a" },
     { "http://foo/{searchTerms}a{inputEncoding}a{language}a",
       "http://foo/XaUTF-8a{language}a" },
     { "http://foo/{inputEncoding}a{searchTerms}a{language}a",
       "http://foo/UTF-8aXa{language}a" },
     { "http://foo/{inputEncoding}a{language}a{searchTerms}a",
       "http://foo/UTF-8a{language}aXa" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     std::string expected_result = test_data[i].expected_result;
     ReplaceSubstringsAfterOffset(&expected_result, 0, "{language}",
                                  search_terms_data_.GetApplicationLocale());
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(ASCIIToUTF16("X")),
         search_terms_data_));
@@ skipping 19 matching lines @@
       "http://foo/?{searchTerms}{inputEncoding}",
       "http://foo/?blahUTF-8" },
     { "Shift_JIS", base::UTF8ToUTF16("\xe3\x81\x82"),
       "http://foo/{searchTerms}/bar",
       "http://foo/%82%A0/bar"},
     { "Shift_JIS", base::UTF8ToUTF16("\xe3\x81\x82 \xe3\x81\x84"),
       "http://foo/{searchTerms}/bar",
       "http://foo/%82%A0%20%82%A2/bar"},
   };
   TemplateURLData data;
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     data.input_encodings.clear();
     data.input_encodings.push_back(test_data[i].encoding);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     GURL result(url.url_ref().ReplaceSearchTerms(
         TemplateURLRef::SearchTermsArgs(test_data[i].search_term),
         search_terms_data_));
     ASSERT_TRUE(result.is_valid());
@@ skipping 36 matching lines @@
       "http://foo/?foo" },
     // A non-Google search provider with HTTPS should allow AQS.
     { ASCIIToUTF16("foo"),
       "chrome.0.0l6",
       "https://www.google.com",
       "https://foo?{searchTerms}{google:assistedQueryStats}",
       "https://foo/?fooaqs=chrome.0.0l6&" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.assisted_query_stats = test_data[i].aqs;
     search_terms_data_.set_google_base_url(test_data[i].base_url);
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
@@ skipping 17 matching lines @@
       2,
       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
       "http://www.google.com/?foo&cp=2&" },
     { ASCIIToUTF16("foo"),
       15,
       "{google:baseURL}?{searchTerms}&{google:cursorPosition}",
       "http://www.google.com/?foo&cp=15&" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.cursor_position = test_data[i].cursor_position;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
@@ skipping 16 matching lines @@
       metrics::OmniboxInputType::URL,
       "{google:baseURL}?{searchTerms}&{google:inputType}",
       "http://www.google.com/?foo&oit=3&" },
     { ASCIIToUTF16("foo"),
       metrics::OmniboxInputType::FORCED_QUERY,
       "{google:baseURL}?{searchTerms}&{google:inputType}",
       "http://www.google.com/?foo&oit=5&" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.input_type = test_data[i].input_type;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
@@ skipping 16 matching lines @@
       "",
       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
       "http://www.google.com/?foo&" },
     { ASCIIToUTF16("foo"),
       "http://g.com/+-/*&=",
       "{google:baseURL}?{searchTerms}&{google:currentPageUrl}",
       "http://www.google.com/?foo&url=http%3A%2F%2Fg.com%2F%2B-%2F*%26%3D&" },
   };
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
     ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
     TemplateURLRef::SearchTermsArgs search_terms_args(test_data[i].search_term);
     search_terms_args.current_page_url = test_data[i].current_page_url;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
@@ skipping 16 matching lines @@
       42,
       "http://bar/foo?es_sm=42&q=foobar" },
   };
   TemplateURLData data;
   data.SetURL("http://bar/foo?{google:omniboxStartMarginParameter}"
               "q={searchTerms}");
   data.input_encodings.push_back("UTF-8");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     TemplateURLRef::SearchTermsArgs search_terms_args(ASCIIToUTF16("foobar"));
     search_terms_args.enable_omnibox_start_margin =
         test_data[i].enable_omnibox_start_margin;
     search_terms_data_.set_omnibox_start_margin(
         test_data[i].omnibox_start_margin);
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
@@ skipping 16 matching lines @@
     { 0, base::string16(), "http://bar/foo?oq=&q=foobar" },
     { 1, ASCIIToUTF16("foo"), "http://bar/foo?oq=foo&q=foobar" },
   };
   TemplateURLData data;
   data.SetURL("http://bar/foo?{google:originalQueryForSuggestion}"
               "q={searchTerms}");
   data.input_encodings.push_back("UTF-8");
   TemplateURL url(data);
   EXPECT_TRUE(url.url_ref().IsValid(search_terms_data_));
   ASSERT_TRUE(url.url_ref().SupportsReplacement(search_terms_data_));
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     TemplateURLRef::SearchTermsArgs search_terms_args(
         ASCIIToUTF16("foobar"));
     search_terms_args.accepted_suggestion = test_data[i].accepted_suggestion;
     search_terms_args.original_query =
         test_data[i].original_query_for_suggestion;
     GURL result(url.url_ref().ReplaceSearchTerms(search_terms_args,
                                                  search_terms_data_));
     ASSERT_TRUE(result.is_valid());
     EXPECT_EQ(test_data[i].expected_result, result.spec());
   }
@@ skipping 51 matching lines @@
     // Term in the host shouldn't match.
     { "http://{searchTerms}", "", "", ""},
 
     { "http://blah/?q={searchTerms}", "blah", "/", "q"},
     { "https://blah/?q={searchTerms}", "blah", "/", "q"},
 
     // Single term with extra chars in value should match.
     { "http://blah/?q=stock:{searchTerms}", "blah", "/", "q"},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_data); ++i) {
+  for (size_t i = 0; i < arraysize(test_data); ++i) {
     TemplateURLData data;
     data.SetURL(test_data[i].url);
     TemplateURL url(data);
     EXPECT_EQ(test_data[i].host, url.url_ref().GetHost(search_terms_data_));
     EXPECT_EQ(test_data[i].path, url.url_ref().GetPath(search_terms_data_));
     EXPECT_EQ(test_data[i].search_term_key,
               url.url_ref().GetSearchTermKey(search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, GoogleBaseSuggestURL) {
   static const struct {
     const char* const base_url;
     const char* const base_suggest_url;
   } data[] = {
     { "http://google.com/", "http://google.com/complete/", },
     { "http://www.google.com/", "http://www.google.com/complete/", },
     { "http://www.google.co.uk/", "http://www.google.co.uk/complete/", },
     { "http://www.google.com.by/", "http://www.google.com.by/complete/", },
     { "http://google.com/intl/xx/", "http://google.com/complete/", },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i)
+  for (size_t i = 0; i < arraysize(data); ++i)
     CheckSuggestBaseURL(data[i].base_url, data[i].base_suggest_url);
 }
 
 TEST_F(TemplateURLTest, ParseParameterKnown) {
   std::string parsed_url("{searchTerms}");
   TemplateURLData data;
   data.SetURL(parsed_url);
   TemplateURL url(data);
   TemplateURLRef::Replacements replacements;
   EXPECT_TRUE(url.url_ref().ParseParameter(0, 12, &parsed_url, &replacements));
@@ skipping 533 matching lines @@
     { "http://bar/#output=search&q=foo&oq=foo", true, },
     { "http://bar/webhp#q=foo&oq=foo", true, },
     { "http://bar/#q=foo&oq=foo", true, },
     { "http://bar/?ext=foo&q=foo#ref=bar", true, },
     { "http://bar/url?url=http://www.foo.com/&q=foo#ref=bar", false, },
     { "http://bar/", false, },
     { "http://foo/", false, },
     { "http://bar/newtab", false, },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(url_data); ++i) {
+  for (size_t i = 0; i < arraysize(url_data); ++i) {
     EXPECT_EQ(url_data[i].result,
               search_provider.IsSearchURL(GURL(url_data[i].url),
                                           search_terms_data_));
   }
 }
 
 TEST_F(TemplateURLTest, ReflectsBookmarkBarPinned) {
   TemplateURLData data;
   data.input_encodings.push_back("UTF-8");
   data.SetURL("{google:baseURL}?{google:bookmarkBarPinned}q={searchTerms}");
@@ skipping 109 matching lines @@
     const char* test_name;
     const char* url;
     const char* expected;
   } generate_url_cases[] = {
     { "invalid URL", "foo{searchTerms}", "" },
     { "URL with no replacements", "http://foo/", "http://foo/" },
     { "basic functionality", "http://foo/{searchTerms}",
       "http://foo/blah.blah.blah.blah.blah" }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(generate_url_cases); ++i) {
+  for (size_t i = 0; i < arraysize(generate_url_cases); ++i) {
     TemplateURLData data;
     data.SetURL(generate_url_cases[i].url);
     TemplateURL t_url(data);
     EXPECT_EQ(t_url.GenerateSearchURL(search_terms_data_).spec(),
               generate_url_cases[i].expected)
         << generate_url_cases[i].test_name << " failed.";
   }
 }
 
 TEST_F(TemplateURLTest, PrefetchQueryParameters) {
@@ skipping 10 matching lines @@
   EXPECT_EQ("http://bar/search?q=foo&pfq=full%20query%20text&qha=2338&xssi=t",
             result);
 
   TemplateURL url2(data);
   search_terms_args.prefetch_query.clear();
   search_terms_args.prefetch_query_type.clear();
   result =
       url2.url_ref().ReplaceSearchTerms(search_terms_args, search_terms_data_);
   EXPECT_EQ("http://bar/search?q=foo&xssi=t", result);
 }