Convert ARRAYSIZE_UNSAFE -> arraysize in components/.

components/variations/study_filtering_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/variations/study_filtering.h"
 
 #include <vector>
 
 #include "base/strings/string_split.h"
 #include "components/variations/processed_study.h"
@@ skipping 120 matching lines @@
   } test_cases[] = {
     {"en-US", true, false, false},
     {"en-US,en-CA,fr", true, true, true},
     {"en-US,en-CA,en-GB", true, true, false},
     {"en-GB,en-CA,en-US", true, true, false},
     {"ja,kr,vi", false, false, false},
     {"fr-CA", false, false, false},
     {"", true, true, true},
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     std::vector<std::string> filter_locales;
     Study_Filter filter;
     base::SplitString(test_cases[i].filter_locales, ',', &filter_locales);
     for (size_t j = 0; j < filter_locales.size(); ++j)
       filter.add_locale(filter_locales[j]);
     EXPECT_EQ(test_cases[i].en_us_result,
               internal::CheckStudyLocale(filter, "en-US"));
     EXPECT_EQ(test_cases[i].en_ca_result,
               internal::CheckStudyLocale(filter, "en-CA"));
     EXPECT_EQ(test_cases[i].fr_result,
@@ skipping 59 matching lines @@
     { now - delta, true },
     { now, true },
     { now + delta, false },
   };
 
   Study_Filter filter;
 
   // Start date not set should result in true.
   EXPECT_TRUE(internal::CheckStudyStartDate(filter, now));
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(start_test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(start_test_cases); ++i) {
     filter.set_start_date(TimeToProtoTime(start_test_cases[i].start_date));
     const bool result = internal::CheckStudyStartDate(filter, now);
     EXPECT_EQ(start_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
 TEST(VariationsStudyFilteringTest, CheckStudyVersion) {
   const struct {
     const char* min_version;
@@ skipping 34 matching lines @@
     { "2.4.*", "2.3.4", true },
     { "1.3.*", "2.3.4", false },
     { "1.*", "2.3.4", false },
   };
 
   Study_Filter filter;
 
   // Min/max version not set should result in true.
   EXPECT_TRUE(internal::CheckStudyVersion(filter, base::Version("1.2.3")));
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(min_test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(min_test_cases); ++i) {
     filter.set_min_version(min_test_cases[i].min_version);
     const bool result =
         internal::CheckStudyVersion(filter, Version(min_test_cases[i].version));
     EXPECT_EQ(min_test_cases[i].expected_result, result) <<
         "Min. version case " << i << " failed!";
   }
   filter.clear_min_version();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(max_test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(max_test_cases); ++i) {
     filter.set_max_version(max_test_cases[i].max_version);
     const bool result =
         internal::CheckStudyVersion(filter, Version(max_test_cases[i].version));
     EXPECT_EQ(max_test_cases[i].expected_result, result) <<
         "Max version case " << i << " failed!";
   }
 
   // Check intersection semantics.
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(min_test_cases); ++i) {
-    for (size_t j = 0; j < ARRAYSIZE_UNSAFE(max_test_cases); ++j) {
+  for (size_t i = 0; i < arraysize(min_test_cases); ++i) {
+    for (size_t j = 0; j < arraysize(max_test_cases); ++j) {
       filter.set_min_version(min_test_cases[i].min_version);
       filter.set_max_version(max_test_cases[j].max_version);
 
       if (!min_test_cases[i].expected_result) {
         const bool result =
             internal::CheckStudyVersion(
                 filter, Version(min_test_cases[i].version));
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
 
@@ skipping 40 matching lines @@
     {"", "apple,pear,orange", "fancy INTEL pear GRAPE device", false},
     // Substring, so still invalid.
     {"", "apple,pear,orange", "fancy INTEL SNapple device", false},
     // Empty.
     {"", "apple,pear,orange", "", true},
 
     // Not testing when both are set as it should never occur and should be
     // considered undefined.
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(test_cases); ++i) {
     Study_Filter filter;
     std::vector<std::string> hardware_class;
     base::SplitString(test_cases[i].hardware_class, ',', &hardware_class);
     for (size_t j = 0; j < hardware_class.size(); ++j)
       filter.add_hardware_class(hardware_class[j]);
 
     std::vector<std::string> exclude_hardware_class;
     base::SplitString(test_cases[i].exclude_hardware_class, ',',
                       &exclude_hardware_class);
     for (size_t j = 0; j < exclude_hardware_class.size(); ++j)
@@ skipping 50 matching lines @@
     { now - delta, true },
     { now, true },
     { now + delta, false },
   };
 
   Study study;
 
   // Expiry date not set should result in false.
   EXPECT_FALSE(internal::IsStudyExpired(study, now));
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(expiry_test_cases); ++i) {
+  for (size_t i = 0; i < arraysize(expiry_test_cases); ++i) {
     study.set_expiry_date(TimeToProtoTime(expiry_test_cases[i].expiry_date));
     const bool result = internal::IsStudyExpired(study, now);
     EXPECT_EQ(expiry_test_cases[i].expected_result, result)
         << "Case " << i << " failed!";
   }
 }
 
 TEST(VariationsStudyFilteringTest, ValidateStudy) {
   Study study;
   study.set_default_experiment_name("def");
@@ skipping 32 matching lines @@
 
   default_group->set_name("def");
   EXPECT_TRUE(processed_study.Init(&study, false));
   Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   EXPECT_FALSE(processed_study.Init(&study, false));
 }
 
 }  // namespace variations