Convert ARRAYSIZE_UNSAFE -> arraysize in content/.

content/browser/quota/quota_manager_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 <algorithm>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 451 matching lines @@
     { "http://foo.com:8080/",  kTemp,  15 },
     { "http://bar.com/",       kTemp,  20 },
     { "http://bar.com/",       kPerm,  50 },
   };
   static const MockOriginData kData2[] = {
     { "https://foo.com/",      kTemp,  30 },
     { "https://foo.com:8081/", kTemp,  35 },
     { "http://bar.com/",       kPerm,  40 },
     { "http://example.com/",   kPerm,  40 },
   };
-  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  RegisterClient(CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem));
-  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  RegisterClient(CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase));
 
   GetUsageInfo();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(4U, usage_info().size());
   for (size_t i = 0; i < usage_info().size(); ++i) {
     const UsageInfo& info = usage_info()[i];
     if (info.host == "foo.com" && info.type == kTemp) {
       EXPECT_EQ(10 + 15 + 30 + 35, info.usage);
     } else if (info.host == "bar.com" && info.type == kTemp) {
       EXPECT_EQ(20, info.usage);
     } else if (info.host == "bar.com" && info.type == kPerm) {
       EXPECT_EQ(50 + 40, info.usage);
     } else if (info.host == "example.com" && info.type == kPerm) {
       EXPECT_EQ(40, info.usage);
     } else {
       ADD_FAILURE()
           << "Unexpected host, type: " << info.host << ", " << info.type;
     }
   }
 }
 
 TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(0, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
@@ skipping 72 matching lines @@
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp,  10 },
     { "http://foo.com:8080/",   kTemp,  20 },
     { "http://bar.com/",        kTemp,   5 },
     { "https://bar.com/",       kTemp,   7 },
     { "http://baz.com/",        kTemp,  30 },
     { "http://foo.com/",        kPerm,  40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
   // This time explicitly sets a temporary global quota.
   SetTemporaryGlobalQuota(100);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(100, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
@@ skipping 22 matching lines @@
     { "http://installed/",            kPerm, 16 },
   };
   static const MockOriginData kData2[] = {
     { "https://foo.com/",             kTemp, 128 },
     { "http://example.com/",          kPerm, 256 },
     { "http://unlimited/",            kTemp, 512 },
     { "http://installed/",            kTemp, 1024 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
-  RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  RegisterClient(CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem));
-  RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  RegisterClient(CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase));
 
   const int64 kTempQuotaBase =
       GetAvailableDiskSpaceForTest(base::FilePath()) / kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1 + 128, usage());
 
@@ skipping 42 matching lines @@
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(4 + 8 + 16 + 256, usage());
   EXPECT_EQ(8, unlimited_usage());
 }
 
 void QuotaManagerTest::GetUsage_WithModifyTestBody(const StorageType type) {
   const MockOriginData data[] = {
     { "http://foo.com/",   type,  10 },
     { "http://foo.com:1/", type,  20 },
   };
-  MockStorageClient* client = CreateClient(data, ARRAYSIZE_UNSAFE(data),
+  MockStorageClient* client = CreateClient(data, arraysize(data),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), type);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
 
   client->ModifyOriginAndNotify(GURL("http://foo.com/"), type, 30);
   client->ModifyOriginAndNotify(GURL("http://foo.com:1/"), type, -5);
@@ skipping 21 matching lines @@
   GetUsage_WithModifyTestBody(kTemp);
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
     { "http://foo.com:8080/",   kTemp, 20 },
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
   SetTemporaryGlobalQuota(100);
   base::RunLoop().RunUntilIdle();
 
   const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
@@ skipping 13 matching lines @@
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kTemp, 10 },
     { "http://foo.com:8080/",   kTemp, 20 },
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
   SetTemporaryGlobalQuota(100);
   base::RunLoop().RunUntilIdle();
 
   set_additional_callback_count(0);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kTemp);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
                                  kTemp);
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
 
   // Nuke before waiting for callbacks.
   set_quota_manager(NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Overbudget) {
   static const MockOriginData kData[] = {
     { "http://usage1/",    kTemp,   1 },
     { "http://usage10/",   kTemp,  10 },
     { "http://usage200/",  kTemp, 200 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
   SetTemporaryGlobalQuota(100);
   base::RunLoop().RunUntilIdle();
 
   const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://usage1/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1, usage());
@@ skipping 12 matching lines @@
   EXPECT_EQ(kPerHostQuota, quota());  // should be clamped to the nominal quota
 }
 
 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Unlimited) {
   static const MockOriginData kData[] = {
     { "http://usage10/",   kTemp,    10 },
     { "http://usage50/",   kTemp,    50 },
     { "http://unlimited/", kTemp,  4000 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   // Test when not overbugdet.
   SetTemporaryGlobalQuota(1000);
   base::RunLoop().RunUntilIdle();
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(10 + 50 + 4000, usage());
@@ skipping 207 matching lines @@
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm, 10 },
     { "http://foo.com:8080/",   kPerm, 20 },
     { "https://foo.com/",       kPerm, 13 },
     { "https://foo.com:8081/",  kPerm, 19 },
     { "http://bar.com/",        kPerm,  5 },
     { "https://bar.com/",       kPerm,  7 },
     { "http://baz.com/",        kPerm, 30 },
     { "http://foo.com/",        kTemp, 40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
   SetPersistentHostQuota("foo.com", 100);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20 + 13 + 19, usage());
   EXPECT_EQ(100, quota());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsage_WithModify) {
   GetUsage_WithModifyTestBody(kPerm);
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_WithAdditionalTasks) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm,  10 },
     { "http://foo.com:8080/",   kPerm,  20 },
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
   SetPersistentHostQuota("foo.com", 100);
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(100, quota());
 
   set_additional_callback_count(0);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
                                  kPerm);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10 + 20, usage());
   EXPECT_EQ(2, additional_callback_count());
 }
 
 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",        kPerm,  10 },
     { "http://foo.com:8080/",   kPerm,  20 },
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
   SetPersistentHostQuota("foo.com", 100);
 
   set_additional_callback_count(0);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"), kPerm);
   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kPerm);
 
   // Nuke before waiting for callbacks.
   set_quota_manager(NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaErrorAbort, status());
 }
 
 TEST_F(QuotaManagerTest, GetUsage_Simple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kPerm,       1 },
     { "http://foo.com:1/", kPerm,      20 },
     { "http://bar.com/",   kTemp,     300 },
     { "https://buz.com/",  kTemp,    4000 },
     { "http://buz.com/",   kTemp,   50000 },
     { "http://bar.com:1/", kPerm,  600000 },
     { "http://foo.com/",   kTemp, 7000000 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
   GetGlobalUsage(kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(usage(), 1 + 20 + 600000);
   EXPECT_EQ(0, unlimited_usage());
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000);
@@ skipping 12 matching lines @@
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kPerm,       1 },
     { "http://foo.com:1/", kPerm,      20 },
     { "http://bar.com/",   kTemp,     300 },
     { "https://buz.com/",  kTemp,    4000 },
     { "http://buz.com/",   kTemp,   50000 },
     { "http://bar.com:1/", kPerm,  600000 },
     { "http://foo.com/",   kTemp, 7000000 },
   };
 
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(usage(), 1 + 20 + 600000);
   EXPECT_EQ(0, unlimited_usage());
 
   client->ModifyOriginAndNotify(
       GURL("http://foo.com/"), kPerm, 80000000);
@@ skipping 28 matching lines @@
   EXPECT_EQ(usage(), 4000 + 50000 + 900000000);
 }
 
 TEST_F(QuotaManagerTest, GetUsage_WithDeleteOrigin) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
     { "http://foo.com:1/", kTemp,    20 },
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_host_tmp = usage();
@@ skipping 34 matching lines @@
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
     { "http://foo.com/",   kPerm,   700 },
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
   int64 predelete_host_pers = usage();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData1); ++i)
+  for (size_t i = 0; i < arraysize(kData1); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData1[i].origin), kData1[i].type);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
+  for (size_t i = 0; i < arraysize(kData2); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData2[i].origin), kData2[i].type);
   base::RunLoop().RunUntilIdle();
 
   EvictOriginData(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
 
   DumpOriginInfoTable();
   base::RunLoop().RunUntilIdle();
 
@@ skipping 19 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, EvictOriginDataWithDeletionError) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,       1 },
     { "http://foo.com:1/", kTemp,      20 },
     { "http://foo.com/",   kPerm,     300 },
     { "http://bar.com/",   kTemp,    4000 },
   };
   static const int kNumberOfTemporaryOrigins = 3;
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
   int64 predelete_host_pers = usage();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i)
+  for (size_t i = 0; i < arraysize(kData); ++i)
     NotifyStorageAccessed(client, GURL(kData[i].origin), kData[i].type);
   base::RunLoop().RunUntilIdle();
 
   client->AddOriginToErrorSet(GURL("http://foo.com/"), kTemp);
 
   for (int i = 0;
        i < QuotaManager::kThresholdOfErrorsToBeBlacklisted + 1;
        ++i) {
     EvictOriginData(GURL("http://foo.com/"), kTemp);
     base::RunLoop().RunUntilIdle();
@@ skipping 49 matching lines @@
 
 TEST_F(QuotaManagerTest, GetUsageAndQuotaForEviction) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,       1 },
     { "http://foo.com:1/", kTemp,      20 },
     { "http://foo.com/",   kPerm,     300 },
     { "http://unlimited/", kTemp,    4000 },
   };
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   SetTemporaryGlobalQuota(10000000);
   base::RunLoop().RunUntilIdle();
 
   GetUsageAndQuotaForEviction();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(21, limited_usage());
   EXPECT_EQ(10000000, quota());
   EXPECT_LE(0, available_space());
 }
 
 TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   int64 predelete_host_tmp = usage();
@@ skipping 42 matching lines @@
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
     { "http://foo.com/",   kPerm,   700 },
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
@@ skipping 65 matching lines @@
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 50000 },
     { "http://foo.com:1/", kTemp,  6000 },
     { "http://foo.com/",   kPerm,   700 },
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_foo_tmp = usage();
 
   GetHostUsage("bar.com", kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_bar_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_foo_pers = usage();
 
   GetHostUsage("bar.com", kPerm);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_bar_pers = usage();
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData1); ++i)
+  for (size_t i = 0; i < arraysize(kData1); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData1[i].origin), kData1[i].type);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
+  for (size_t i = 0; i < arraysize(kData2); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData2[i].origin), kData2[i].type);
   base::RunLoop().RunUntilIdle();
 
   reset_status_callback_count();
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
   base::RunLoop().RunUntilIdle();
 
@@ skipping 33 matching lines @@
   EXPECT_EQ(predelete_bar_pers, usage());
 }
 
 TEST_F(QuotaManagerTest, GetCachedOrigins) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,       1 },
     { "http://a.com:1/", kTemp,      20 },
     { "http://b.com/",   kPerm,     300 },
     { "http://c.com/",   kTemp,    4000 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   // TODO(kinuko): Be careful when we add cache pruner.
 
   std::set<GURL> origins;
   GetCachedOrigins(kTemp, &origins);
   EXPECT_TRUE(origins.empty());
 
   // No matter how we make queries the quota manager tries to cache all
   // the origins at startup.
   GetHostUsage("a.com", kTemp);
   base::RunLoop().RunUntilIdle();
   GetCachedOrigins(kTemp, &origins);
   EXPECT_EQ(3U, origins.size());
 
   GetHostUsage("b.com", kTemp);
   base::RunLoop().RunUntilIdle();
   GetCachedOrigins(kTemp, &origins);
   EXPECT_EQ(3U, origins.size());
 
   GetCachedOrigins(kPerm, &origins);
   EXPECT_TRUE(origins.empty());
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   GetCachedOrigins(kTemp, &origins);
   EXPECT_EQ(3U, origins.size());
 
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i) {
+  for (size_t i = 0; i < arraysize(kData); ++i) {
     if (kData[i].type == kTemp)
       EXPECT_TRUE(origins.find(GURL(kData[i].origin)) != origins.end());
   }
 }
 
 TEST_F(QuotaManagerTest, NotifyAndLRUOrigin) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GURL origin;
   GetLRUOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(lru_origin().is_empty());
 
   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
   GetLRUOrigin(kTemp);
@@ skipping 19 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, GetLRUOriginWithOriginInUse) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GURL origin;
   GetLRUOrigin(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(lru_origin().is_empty());
 
   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
   NotifyStorageAccessed(client, GURL("http://b.com/"), kPerm);
@@ skipping 34 matching lines @@
 }
 
 TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,  0 },
     { "http://a.com:1/", kTemp,  0 },
     { "https://a.com/",  kTemp,  0 },
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetOriginsModifiedSince(kTemp, base::Time());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(modified_origins().empty());
   EXPECT_EQ(modified_origins_type(), kTemp);
 
   base::Time time1 = client->IncrementMockTime();
   client->ModifyOriginAndNotify(GURL("http://a.com/"), kTemp, 10);
   client->ModifyOriginAndNotify(GURL("http://a.com:1/"), kTemp, 10);
   client->ModifyOriginAndNotify(GURL("http://b.com/"), kPerm, 10);
   base::Time time2 = client->IncrementMockTime();
   client->ModifyOriginAndNotify(GURL("https://a.com/"), kTemp, 10);
   client->ModifyOriginAndNotify(GURL("http://c.com/"), kTemp, 10);
   base::Time time3 = client->IncrementMockTime();
 
   GetOriginsModifiedSince(kTemp, time1);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4U, modified_origins().size());
   EXPECT_EQ(modified_origins_type(), kTemp);
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i) {
+  for (size_t i = 0; i < arraysize(kData); ++i) {
     if (kData[i].type == kTemp)
       EXPECT_EQ(1U, modified_origins().count(GURL(kData[i].origin)));
   }
 
   GetOriginsModifiedSince(kTemp, time2);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2U, modified_origins().size());
 
   GetOriginsModifiedSince(kTemp, time3);
   base::RunLoop().RunUntilIdle();
@@ skipping 16 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   DumpQuotaTable();
   base::RunLoop().RunUntilIdle();
 
   const QuotaTableEntry kEntries[] = {
     QuotaTableEntry("example1.com", kPerm, 1),
     QuotaTableEntry("example2.com", kPerm, 20),
     QuotaTableEntry("example3.com", kPerm, 300),
   };
-  std::set<QuotaTableEntry> entries
-      (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
+  std::set<QuotaTableEntry> entries(kEntries, kEntries + arraysize(kEntries));
 
   typedef QuotaTableEntries::const_iterator iterator;
   for (iterator itr(quota_entries().begin()), end(quota_entries().end());
        itr != end; ++itr) {
     SCOPED_TRACE(testing::Message()
                  << "host = " << itr->host << ", "
                  << "quota = " << itr->quota);
     EXPECT_EQ(1u, entries.erase(*itr));
   }
   EXPECT_TRUE(entries.empty());
@@ skipping 18 matching lines @@
 
   DumpOriginInfoTable();
   base::RunLoop().RunUntilIdle();
 
   typedef std::pair<GURL, StorageType> TypedOrigin;
   typedef std::pair<TypedOrigin, int> Entry;
   const Entry kEntries[] = {
     make_pair(make_pair(GURL("http://example.com/"), kTemp), 1),
     make_pair(make_pair(GURL("http://example.com/"), kPerm), 2),
   };
-  std::set<Entry> entries
-      (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
+  std::set<Entry> entries(kEntries, kEntries + arraysize(kEntries));
 
   typedef OriginInfoTableEntries::const_iterator iterator;
   for (iterator itr(origin_info_entries().begin()),
                 end(origin_info_entries().end());
        itr != end; ++itr) {
     SCOPED_TRACE(testing::Message()
                  << "host = " << itr->origin << ", "
                  << "type = " << itr->type << ", "
                  << "used_count = " << itr->used_count);
     EXPECT_EQ(1u, entries.erase(
@@ skipping 20 matching lines @@
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 2 },
   };
   static const MockOriginData kData3[] = {
     { "http://foo.com/",   kTemp, 4 },
   };
   static const MockOriginData kData4[] = {
     { "http://foo.com/",   kTemp, 8 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kAppcache);
-  MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
+  MockStorageClient* client3 = CreateClient(kData3, arraysize(kData3),
       QuotaClient::kDatabase);
-  MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
+  MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_foo_tmp = usage();
 
@@ skipping 29 matching lines @@
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com:2222/",   kTemp, 2 },
   };
   static const MockOriginData kData3[] = {
     { "http://foo.com:3333/",   kTemp, 4 },
   };
   static const MockOriginData kData4[] = {
     { "http://foo.com:4444/",   kTemp, 8 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kAppcache);
-  MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
+  MockStorageClient* client3 = CreateClient(kData3, arraysize(kData3),
       QuotaClient::kDatabase);
-  MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
+  MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_foo_tmp = usage();
 
@@ skipping 28 matching lines @@
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com/",   kTemp, 2 },
   };
   static const MockOriginData kData3[] = {
     { "http://foo.com/",   kTemp, 4 },
   };
   static const MockOriginData kData4[] = {
     { "http://foo.com/",   kTemp, 8 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kAppcache);
-  MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
+  MockStorageClient* client3 = CreateClient(kData3, arraysize(kData3),
       QuotaClient::kDatabase);
-  MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
+  MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_foo_tmp = usage();
 
@@ skipping 18 matching lines @@
   };
   static const MockOriginData kData2[] = {
     { "http://foo.com:2222/",   kTemp, 2 },
   };
   static const MockOriginData kData3[] = {
     { "http://foo.com:3333/",   kTemp, 4 },
   };
   static const MockOriginData kData4[] = {
     { "http://foo.com:4444/",   kTemp, 8 },
   };
-  MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
+  MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
-  MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
+  MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kAppcache);
-  MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
+  MockStorageClient* client3 = CreateClient(kData3, arraysize(kData3),
       QuotaClient::kDatabase);
-  MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
+  MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   const int64 predelete_foo_tmp = usage();
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
 }
 
 TEST_F(QuotaManagerTest, GetUsageAndQuota_Incognito) {
   ResetQuotaManager(true);
 
   static const MockOriginData kData[] = {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
+  RegisterClient(CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem));
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(0, quota());
 
   SetTemporaryGlobalQuota(100);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
@@ skipping 11 matching lines @@
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 }
 
 }  // namespace content