Convert ARRAYSIZE_UNSAFE -> arraysize in content/.

content/browser/fileapi/file_system_quota_client_unittest.cc

 // Copyright 2013 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/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
@@ skipping 232 matching lines @@
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
 
   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
 }
 
 TEST_F(FileSystemQuotaClientTest, NoFileTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, OneFileTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {false, "foo", 4921, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(4921 + file_paths_cost,
         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, TwoFilesTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {false, "foo", 10310, kDummyURL1, kTemporary},
     {false, "bar", 41, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(10310 + 41 + file_paths_cost,
         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, EmptyFilesTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {false, "foo", 0, kDummyURL1, kTemporary},
     {false, "bar", 0, kDummyURL1, kTemporary},
     {false, "baz", 0, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(file_paths_cost,
         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, SubDirectoryTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {true, "dirtest", 0, kDummyURL1, kTemporary},
     {false, "dirtest/foo", 11921, kDummyURL1, kTemporary},
     {false, "bar", 4814, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(11921 + 4814 + file_paths_cost,
         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, MultiTypeTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {true, "dirtest", 0, kDummyURL1, kTemporary},
     {false, "dirtest/foo", 133, kDummyURL1, kTemporary},
     {false, "bar", 14, kDummyURL1, kTemporary},
     {true, NULL, 0, kDummyURL1, kPersistent},
     {true, "dirtest", 0, kDummyURL1, kPersistent},
     {false, "dirtest/foo", 193, kDummyURL1, kPersistent},
     {false, "bar", 9, kDummyURL1, kPersistent},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost_temporary = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
   const int64 file_paths_cost_persistent = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(133 + 14 + file_paths_cost_temporary,
         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
     EXPECT_EQ(193 + 9 + file_paths_cost_persistent,
         GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, MultiDomainTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {true, "dir1", 0, kDummyURL1, kTemporary},
     {false, "dir1/foo", 1331, kDummyURL1, kTemporary},
     {false, "bar", 134, kDummyURL1, kTemporary},
     {true, NULL, 0, kDummyURL1, kPersistent},
     {true, "dir2", 0, kDummyURL1, kPersistent},
     {false, "dir2/foo", 1903, kDummyURL1, kPersistent},
     {false, "bar", 19, kDummyURL1, kPersistent},
     {true, NULL, 0, kDummyURL2, kTemporary},
     {true, "dom", 0, kDummyURL2, kTemporary},
     {false, "dom/fan", 1319, kDummyURL2, kTemporary},
     {false, "bar", 113, kDummyURL2, kTemporary},
     {true, NULL, 0, kDummyURL2, kPersistent},
     {true, "dom", 0, kDummyURL2, kPersistent},
     {false, "dom/fan", 2013, kDummyURL2, kPersistent},
     {false, "baz", 18, kDummyURL2, kPersistent},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost_temporary1 = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
   const int64 file_paths_cost_persistent1 =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           kDummyURL1, kPersistent);
   const int64 file_paths_cost_temporary2 = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL2, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL2, kTemporary);
   const int64 file_paths_cost_persistent2 =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           kDummyURL2, kPersistent);
 
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(1331 + 134 + file_paths_cost_temporary1,
         GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
     EXPECT_EQ(1903 + 19 + file_paths_cost_persistent1,
         GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
     EXPECT_EQ(1319 + 113 + file_paths_cost_temporary2,
         GetOriginUsage(quota_client.get(), kDummyURL2, kTemporary));
     EXPECT_EQ(2013 + 18 + file_paths_cost_persistent2,
         GetOriginUsage(quota_client.get(), kDummyURL2, kPersistent));
   }
 }
 
 TEST_F(FileSystemQuotaClientTest, GetUsage_MultipleTasks) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {false, "foo",   11, kDummyURL1, kTemporary},
     {false, "bar",   22, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost = ComputeFilePathsCostForOriginAndType(
-      kFiles, ARRAYSIZE_UNSAFE(kFiles), kDummyURL1, kTemporary);
+      kFiles, arraysize(kFiles), kDummyURL1, kTemporary);
 
   // Dispatching three GetUsage tasks.
   set_additional_callback_count(0);
   GetOriginUsageAsync(quota_client.get(), kDummyURL1, kTemporary);
   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(11 + 22 + file_paths_cost, usage());
   EXPECT_EQ(2, additional_callback_count());
 
   // Once more, in a different order.
   set_additional_callback_count(0);
   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
   GetOriginUsageAsync(quota_client.get(), kDummyURL1, kTemporary);
   RunAdditionalOriginUsageTask(quota_client.get(), kDummyURL1, kTemporary);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(11 + 22 + file_paths_cost, usage());
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(FileSystemQuotaClientTest, GetOriginsForType) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {true, NULL, 0, kDummyURL2, kTemporary},
     {true, NULL, 0, kDummyURL3, kPersistent},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
 
   std::set<GURL> origins = GetOriginsForType(quota_client.get(), kTemporary);
   EXPECT_EQ(2U, origins.size());
   EXPECT_TRUE(origins.find(GURL(kDummyURL1)) != origins.end());
   EXPECT_TRUE(origins.find(GURL(kDummyURL2)) != origins.end());
   EXPECT_TRUE(origins.find(GURL(kDummyURL3)) == origins.end());
 }
 
 TEST_F(FileSystemQuotaClientTest, GetOriginsForHost) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(false));
   const char* kURL1 = "http://foo.com/";
   const char* kURL2 = "https://foo.com/";
   const char* kURL3 = "http://foo.com:1/";
   const char* kURL4 = "http://foo2.com/";
   const char* kURL5 = "http://foo.com:2/";
   const TestFile kFiles[] = {
     {true, NULL, 0, kURL1, kTemporary},
     {true, NULL, 0, kURL2, kTemporary},
     {true, NULL, 0, kURL3, kTemporary},
     {true, NULL, 0, kURL4, kTemporary},
     {true, NULL, 0, kURL5, kPersistent},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
 
   std::set<GURL> origins = GetOriginsForHost(
       quota_client.get(), kTemporary, "foo.com");
   EXPECT_EQ(3U, origins.size());
   EXPECT_TRUE(origins.find(GURL(kURL1)) != origins.end());
   EXPECT_TRUE(origins.find(GURL(kURL2)) != origins.end());
   EXPECT_TRUE(origins.find(GURL(kURL3)) != origins.end());
   EXPECT_TRUE(origins.find(GURL(kURL4)) == origins.end());  // Different host.
   EXPECT_TRUE(origins.find(GURL(kURL5)) == origins.end());  // Different type.
 }
 
 TEST_F(FileSystemQuotaClientTest, IncognitoTest) {
   scoped_ptr<FileSystemQuotaClient> quota_client(NewQuotaClient(true));
   const TestFile kFiles[] = {
     {true, NULL, 0, kDummyURL1, kTemporary},
     {false, "foo", 10, kDummyURL1, kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
 
   // Having files in the usual directory wouldn't affect the result
   // queried in incognito mode.
   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kTemporary));
   EXPECT_EQ(0, GetOriginUsage(quota_client.get(), kDummyURL1, kPersistent));
 
   std::set<GURL> origins = GetOriginsForType(quota_client.get(), kTemporary);
   EXPECT_EQ(0U, origins.size());
   origins = GetOriginsForHost(quota_client.get(), kTemporary, "www.dummy.org");
   EXPECT_EQ(0U, origins.size());
@@ skipping 10 matching lines @@
     {false, "c",  4, "http://foo.com/",  kPersistent},
     {true, NULL,  0, "http://bar.com/",  kTemporary},
     {false, "d",  8, "http://bar.com/",  kTemporary},
     {true, NULL,  0, "http://bar.com/",  kPersistent},
     {false, "e", 16, "http://bar.com/",  kPersistent},
     {true, NULL,  0, "https://bar.com/", kPersistent},
     {false, "f", 32, "https://bar.com/", kPersistent},
     {true, NULL,  0, "https://bar.com/", kTemporary},
     {false, "g", 64, "https://bar.com/", kTemporary},
   };
-  InitializeOriginFiles(quota_client.get(), kFiles, ARRAYSIZE_UNSAFE(kFiles));
+  InitializeOriginFiles(quota_client.get(), kFiles, arraysize(kFiles));
   const int64 file_paths_cost_temporary_foo_https =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           "https://foo.com/", kTemporary);
   const int64 file_paths_cost_persistent_foo =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           "http://foo.com/", kPersistent);
   const int64 file_paths_cost_temporary_bar =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           "http://bar.com/", kTemporary);
   const int64 file_paths_cost_temporary_bar_https =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           "https://bar.com/", kTemporary);
   const int64 file_paths_cost_persistent_bar_https =
-      ComputeFilePathsCostForOriginAndType(kFiles, ARRAYSIZE_UNSAFE(kFiles),
+      ComputeFilePathsCostForOriginAndType(kFiles, arraysize(kFiles),
           "https://bar.com/", kPersistent);
 
   DeleteOriginData(quota_client.get(), "http://foo.com/", kTemporary);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(storage::kQuotaStatusOk, status());
 
   DeleteOriginData(quota_client.get(), "http://bar.com/", kPersistent);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(storage::kQuotaStatusOk, status());
 
@@ skipping 24 matching lines @@
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kPersistent));
   EXPECT_EQ(64 + file_paths_cost_temporary_bar_https,
             GetOriginUsage(quota_client.get(),
                            "https://bar.com/",
                            kTemporary));
 }
 
 }  // namespace content