Convert ARRAYSIZE_UNSAFE -> arraysize in net/.

net/ftp/ftp_util_unittest.cc

 // Copyright (c) 2011 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 "net/ftp/ftp_util.h"
 
 #include "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 16 matching lines @@
     { "/a",         "a"           },
     { "/a/b",       "a:[000000]b" },
     { "/a/b/c",     "a:[b]c"      },
     { "/a/b/c/d",   "a:[b.c]d"    },
     { "/a/b/c/d/e", "a:[b.c.d]e"  },
     { "a",          "a"           },
     { "a/b",        "[.a]b"       },
     { "a/b/c",      "[.a.b]c"     },
     { "a/b/c/d",    "[.a.b.c]d"   },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               net::FtpUtil::UnixFilePathToVMS(kTestCases[i].input))
         << kTestCases[i].input;
   }
 }
 
 TEST(FtpUtilTest, UnixDirectoryPathToVMS) {
   const struct {
     const char* input;
     const char* expected_output;
@@ skipping 12 matching lines @@
     { "/a/b/c/d/e/", "a:[b.c.d.e]" },
     { "a",           "[.a]"        },
     { "a/",          "[.a]"        },
     { "a/b",         "[.a.b]"      },
     { "a/b/",        "[.a.b]"      },
     { "a/b/c",       "[.a.b.c]"    },
     { "a/b/c/",      "[.a.b.c]"    },
     { "a/b/c/d",     "[.a.b.c.d]"  },
     { "a/b/c/d/",    "[.a.b.c.d]"  },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               net::FtpUtil::UnixDirectoryPathToVMS(kTestCases[i].input))
         << kTestCases[i].input;
   }
 }
 
 TEST(FtpUtilTest, VMSPathToUnix) {
   const struct {
     const char* input;
     const char* expected_output;
@@ skipping 19 matching lines @@
     { "[.a.b.c.d]",  "a/b/c/d"    },
     { "[.",          ""           },
 
     // UNIX emulation:
     { "/",           "/"          },
     { "/a",          "/a"         },
     { "/a/b",        "/a/b"       },
     { "/a/b/c",      "/a/b/c"     },
     { "/a/b/c/d",    "/a/b/c/d"   },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     EXPECT_EQ(kTestCases[i].expected_output,
               net::FtpUtil::VMSPathToUnix(kTestCases[i].input))
         << kTestCases[i].input;
   }
 }
 
 TEST(FtpUtilTest, LsDateListingToTime) {
   base::Time mock_current_time;
   ASSERT_TRUE(base::Time::FromString("Tue, 15 Nov 1994 12:45:26 GMT",
                                      &mock_current_time));
@@ skipping 35 matching lines @@
     { "\xd0\xb4\xd0\xb5\xd0\xba", "1", "2011", 2011, 12, 1, 0, 0 },
 
     // Test current year detection.
     { "Nov", "01", "12:00", 1994, 11, 1, 12, 0 },
     { "Nov", "15", "12:00", 1994, 11, 15, 12, 0 },
     { "Nov", "16", "12:00", 1993, 11, 16, 12, 0 },
     { "Jan", "01", "08:30", 1994, 1, 1, 8, 30 },
     { "Sep", "02", "09:00", 1994, 9, 2, 9, 0 },
     { "Dec", "06", "21:00", 1993, 12, 6, 21, 0 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %s %s", i,
                                     kTestCases[i].month, kTestCases[i].day,
                                     kTestCases[i].rest));
 
     base::Time time;
     ASSERT_TRUE(net::FtpUtil::LsDateListingToTime(
         UTF8ToUTF16(kTestCases[i].month), UTF8ToUTF16(kTestCases[i].day),
         UTF8ToUTF16(kTestCases[i].rest), mock_current_time, &time));
 
     base::Time::Exploded time_exploded;
@@ skipping 20 matching lines @@
     int expected_day_of_month;
     int expected_hour;
     int expected_minute;
   } kTestCases[] = {
     { "11-01-07", "12:42", 2007, 11, 1, 12, 42 },
     { "11-01-07", "12:42AM", 2007, 11, 1, 0, 42 },
     { "11-01-07", "12:42PM", 2007, 11, 1, 12, 42 },
 
     { "11-01-2007", "12:42", 2007, 11, 1, 12, 42 },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %s", i,
                                     kTestCases[i].date, kTestCases[i].time));
 
     base::Time time;
     ASSERT_TRUE(net::FtpUtil::WindowsDateListingToTime(
                     UTF8ToUTF16(kTestCases[i].date),
                     UTF8ToUTF16(kTestCases[i].time),
                     &time));
 
     base::Time::Exploded time_exploded;
@@ skipping 18 matching lines @@
     { "", 1, "" },
     { "foo abc", 0, "foo abc" },
     { "foo abc", 1, "abc" },
     { "  foo   abc", 0, "foo   abc" },
     { "  foo   abc", 1, "abc" },
     { "  foo   abc", 2, "" },
     { "  foo   abc ", 0, "foo   abc" },
     { "  foo   abc ", 1, "abc" },
     { "  foo   abc ", 2, "" },
   };
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); i++) {
+  for (size_t i = 0; i < arraysize(kTestCases); i++) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: %s %d", i,
                                     kTestCases[i].text, kTestCases[i].column));
 
     EXPECT_EQ(ASCIIToUTF16(kTestCases[i].expected_result),
               net::FtpUtil::GetStringPartAfterColumns(
                   ASCIIToUTF16(kTestCases[i].text), kTestCases[i].column));
   }
 }
 
 }  // namespace