Convert ARRAYSIZE_UNSAFE -> arraysize in content/.

content/browser/fileapi/external_mount_points_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 "storage/browser/fileapi/external_mount_points.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "storage/browser/fileapi/file_system_url.h"
@@ skipping 88 matching lines @@
     { "win2", DRIVE FPL("\\try/separators\\win"), false, NULL },
 #else
     { "win", DRIVE FPL("\\separators\\win"), false, NULL },
     { "win1", DRIVE FPL("\\try/separators\\win1"), false, NULL },
 #endif
     // Win separators, but relative path.
     { "win2", DRIVE FPL("try\\separators\\win2"), false, NULL },
   };
 
   // Test adding mount points.
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     EXPECT_EQ(
         kTestCases[i].success,
         mount_points->RegisterFileSystem(kTestCases[i].name,
                                          storage::kFileSystemTypeNativeLocal,
                                          storage::FileSystemMountOption(),
                                          base::FilePath(kTestCases[i].path)))
         << "Adding mount point: " << kTestCases[i].name << " with path "
         << kTestCases[i].path;
   }
 
   // Test that final mount point presence state is as expected.
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     base::FilePath found_path;
     EXPECT_EQ(kTestCases[i].registered_path != NULL,
               mount_points->GetRegisteredPath(kTestCases[i].name, &found_path))
         << "Test case: " << i;
 
     if (kTestCases[i].registered_path) {
       base::FilePath expected_path(kTestCases[i].registered_path);
       EXPECT_EQ(expected_path.NormalizePathSeparators(), found_path);
     }
   }
@@ skipping 75 matching lines @@
     { DRIVE FPL("/root/foo"), true, FPL("mount") },
     // Mount point contains character whose ASCII code is smaller than file path
     // separator's.
     { DRIVE FPL("/a/b/c(1)/d/e"), true, FPL("c(1)/d/e") },
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
     // Path with win separators mixed in.
     { DRIVE FPL("/a\\b\\c/d"), true, FPL("c/d") },
 #endif
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     // Initialize virtual path with a value.
     base::FilePath virtual_path(DRIVE FPL("/mount"));
     base::FilePath local_path(kTestCases[i].local_path);
     EXPECT_EQ(kTestCases[i].success,
               mount_points->GetVirtualPath(local_path, &virtual_path))
         << "Resolving " << kTestCases[i].local_path;
 
     // There are no guarantees for |virtual_path| value if |GetVirtualPath|
     // fails.
     if (!kTestCases[i].success)
@@ skipping 110 matching lines @@
     {FPL("/empty_path/a/../b"), false, storage::kFileSystemTypeUnknown, FPL(""),
      ""},
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
     {FPL("c/d\\e"), true, storage::kFileSystemTypeNativeLocal,
      DRIVE FPL("/a/b/c/d/e"), "c"},
     {FPL("mount\\a\\b"), true, storage::kFileSystemTypeDrive,
      DRIVE FPL("/root/a/b"), "mount"},
 #endif
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     FileSystemURL cracked = mount_points->CreateCrackedFileSystemURL(
         kTestOrigin,
         storage::kFileSystemTypeExternal,
         base::FilePath(kTestCases[i].path));
 
     EXPECT_EQ(kTestCases[i].expect_valid, cracked.is_valid())
         << "Test case index: " << i;
 
     if (!kTestCases[i].expect_valid)
       continue;
@@ skipping 73 matching lines @@
     {FPL("/empty_path/a/../b"), false, storage::kFileSystemTypeUnknown, FPL(""),
      ""},
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
     {FPL("c/d\\e"), true, storage::kFileSystemTypeNativeLocal,
      DRIVE FPL("/a/b/c/d/e"), "c"},
     {FPL("mount\\a\\b"), true, storage::kFileSystemTypeDrive,
      DRIVE FPL("/root/a/b"), "mount"},
 #endif
   };
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+  for (size_t i = 0; i < arraysize(kTestCases); ++i) {
     std::string cracked_name;
     storage::FileSystemType cracked_type;
     std::string cracked_id;
     base::FilePath cracked_path;
     storage::FileSystemMountOption cracked_option;
     EXPECT_EQ(kTestCases[i].expect_valid,
               mount_points->CrackVirtualPath(base::FilePath(kTestCases[i].path),
                   &cracked_name, &cracked_type, &cracked_id, &cracked_path,
                   &cracked_option))
         << "Test case index: " << i;
@@ skipping 39 matching lines @@
       &option));
   EXPECT_EQ(storage::COPY_SYNC_OPTION_NO_SYNC, option.copy_sync_option());
   EXPECT_TRUE(mount_points->CrackVirtualPath(
       base::FilePath(FPL("sync/file")), &name, &type, &cracked_id, &path,
       &option));
   EXPECT_EQ(storage::COPY_SYNC_OPTION_SYNC, option.copy_sync_option());
 }
 
 }  // namespace content