Convert ARRAYSIZE_UNSAFE -> arraysize in components/.

components/omnibox/autocomplete_input_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/omnibox/autocomplete_input.h"
 
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 139 matching lines @@
     { ASCIIToUTF16("filesystem:http"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("filesystem:"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("chrome-search://"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("chrome-devtools:"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("about://f;"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16("://w"), metrics::OmniboxInputType::QUERY },
     { ASCIIToUTF16(":w"), metrics::OmniboxInputType::QUERY },
     { base::WideToUTF16(L".\u062A"), metrics::OmniboxInputType::UNKNOWN },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
+  for (size_t i = 0; i < arraysize(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input, base::string16::npos,
                             std::string(), GURL(),
                             OmniboxEventProto::INVALID_SPEC, true, false, true,
                             true, TestSchemeClassifier());
     EXPECT_EQ(input_cases[i].type, input.type());
   }
 }
 
 TEST(AutocompleteInputTest, InputTypeWithDesiredTLD) {
@@ skipping 19 matching lines @@
     { ASCIIToUTF16("x@y.com"), metrics::OmniboxInputType::URL,
         std::string("http://x@y.com/") },
     { ASCIIToUTF16("y/z z"), metrics::OmniboxInputType::URL,
         std::string("http://www.y.com/z%20z") },
     { ASCIIToUTF16("abc.com"), metrics::OmniboxInputType::URL,
         std::string("http://abc.com/") },
     { ASCIIToUTF16("foo bar"), metrics::OmniboxInputType::QUERY,
         std::string() },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
+  for (size_t i = 0; i < arraysize(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input, base::string16::npos, "com",
                             GURL(), OmniboxEventProto::INVALID_SPEC, true,
                             false, true, true, TestSchemeClassifier());
     EXPECT_EQ(input_cases[i].type, input.type());
     if (input_cases[i].type == metrics::OmniboxInputType::URL)
       EXPECT_EQ(input_cases[i].spec, input.canonicalized_url().spec());
   }
 }
 
@@ skipping 31 matching lines @@
         Component(12, 11) },
     { ASCIIToUTF16("view-source:"), Component(0, 11), kInvalidComponent },
     { ASCIIToUTF16("view-source:garbage"), kInvalidComponent,
         Component(12, 7) },
     { ASCIIToUTF16("view-source:http://http://foo"), Component(12, 4),
         Component(19, 4) },
     { ASCIIToUTF16("view-source:view-source:http://example.com/"),
         Component(12, 11), kInvalidComponent }
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
+  for (size_t i = 0; i < arraysize(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     Component scheme, host;
     AutocompleteInput::ParseForEmphasizeComponents(input_cases[i].input,
                                                    TestSchemeClassifier(),
                                                    &scheme,
                                                    &host);
     AutocompleteInput input(input_cases[i].input, base::string16::npos,
                             std::string(), GURL(),
                             OmniboxEventProto::INVALID_SPEC, true,
                             false, true, true, TestSchemeClassifier());
@@ skipping 22 matching lines @@
     { ASCIIToUTF16("      foo bar"), 3, ASCIIToUTF16("foo bar"), 0 },
     { ASCIIToUTF16("      foo bar   "), 2, ASCIIToUTF16("foo bar   "), 0 },
 
     // forced query.
     { ASCIIToUTF16("?foo bar"), 2, ASCIIToUTF16("foo bar"), 1 },
     { ASCIIToUTF16("  ?foo bar"), 4, ASCIIToUTF16("foo bar"), 1 },
     { ASCIIToUTF16("?  foo bar"), 4, ASCIIToUTF16("foo bar"), 1 },
     { ASCIIToUTF16("  ?  foo bar"), 6, ASCIIToUTF16("foo bar"), 1 },
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(input_cases); ++i) {
+  for (size_t i = 0; i < arraysize(input_cases); ++i) {
     SCOPED_TRACE(input_cases[i].input);
     AutocompleteInput input(input_cases[i].input,
                             input_cases[i].cursor_position, std::string(),
                             GURL(), OmniboxEventProto::INVALID_SPEC, true,
                             false, true, true, TestSchemeClassifier());
     EXPECT_EQ(input_cases[i].normalized_input, input.text());
     EXPECT_EQ(input_cases[i].normalized_cursor_position,
               input.cursor_position());
   }
 }