Convert ARRAYSIZE_UNSAFE -> arraysize in content/.

content/browser/quota/quota_database_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 <iterator>
 #include <set>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 37 matching lines @@
     EXPECT_TRUE(kDbFile.empty() || base::PathExists(kDbFile));
   }
 
   void UpgradeSchemaV2toV3(const base::FilePath& kDbFile) {
     const QuotaTableEntry entries[] = {
       QuotaTableEntry("a", kStorageTypeTemporary,  1),
       QuotaTableEntry("b", kStorageTypeTemporary,  2),
       QuotaTableEntry("c", kStorageTypePersistent, 3),
     };
 
-    CreateV2Database(kDbFile, entries, ARRAYSIZE_UNSAFE(entries));
+    CreateV2Database(kDbFile, entries, arraysize(entries));
 
     QuotaDatabase db(kDbFile);
     EXPECT_TRUE(db.LazyOpen(true));
     EXPECT_TRUE(db.db_.get());
 
     typedef EntryVerifier<QuotaTableEntry> Verifier;
-    Verifier verifier(entries, entries + ARRAYSIZE_UNSAFE(entries));
+    Verifier verifier(entries, entries + arraysize(entries));
     EXPECT_TRUE(db.DumpQuotaTable(
         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
     EXPECT_TRUE(verifier.table.empty());
   }
 
   void HostQuota(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     ASSERT_TRUE(db.LazyOpen(true));
 
     const char* kHost = "foo.com";
@@ skipping 204 matching lines @@
     EXPECT_EQ(0U, origins.count(kOrigin3));
   }
 
   void RegisterInitialOriginInfo(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
 
     const GURL kOrigins[] = {
       GURL("http://a/"),
       GURL("http://b/"),
       GURL("http://c/") };
-    std::set<GURL> origins(kOrigins, kOrigins + ARRAYSIZE_UNSAFE(kOrigins));
+    std::set<GURL> origins(kOrigins, kOrigins + arraysize(kOrigins));
 
     EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 
     int used_count = -1;
     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
                                        kStorageTypeTemporary,
                                        &used_count));
     EXPECT_EQ(0, used_count);
 
     EXPECT_TRUE(db.SetOriginLastAccessTime(
@@ skipping 28 matching lines @@
     }
   };
 
   void DumpQuotaTable(const base::FilePath& kDbFile) {
     QuotaTableEntry kTableEntries[] = {
       QuotaTableEntry("http://go/", kStorageTypeTemporary, 1),
       QuotaTableEntry("http://oo/", kStorageTypeTemporary, 2),
       QuotaTableEntry("http://gle/", kStorageTypePersistent, 3)
     };
     QuotaTableEntry* begin = kTableEntries;
-    QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
+    QuotaTableEntry* end = kTableEntries + arraysize(kTableEntries);
 
     QuotaDatabase db(kDbFile);
     EXPECT_TRUE(db.LazyOpen(true));
     AssignQuotaTable(db.db_.get(), begin, end);
     db.Commit();
 
     typedef EntryVerifier<QuotaTableEntry> Verifier;
     Verifier verifier(begin, end);
     EXPECT_TRUE(db.DumpQuotaTable(
         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
     EXPECT_TRUE(verifier.table.empty());
   }
 
   void DumpOriginInfoTable(const base::FilePath& kDbFile) {
     base::Time now(base::Time::Now());
     typedef QuotaDatabase::OriginInfoTableEntry Entry;
     Entry kTableEntries[] = {
       Entry(GURL("http://go/"), kStorageTypeTemporary, 2147483647, now, now),
       Entry(GURL("http://oo/"), kStorageTypeTemporary, 0, now, now),
       Entry(GURL("http://gle/"), kStorageTypeTemporary, 1, now, now),
     };
     Entry* begin = kTableEntries;
-    Entry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
+    Entry* end = kTableEntries + arraysize(kTableEntries);
 
     QuotaDatabase db(kDbFile);
     EXPECT_TRUE(db.LazyOpen(true));
     AssignOriginInfoTable(db.db_.get(), begin, end);
     db.Commit();
 
     typedef EntryVerifier<Entry> Verifier;
     Verifier verifier(begin, end);
     EXPECT_TRUE(db.DumpOriginInfoTable(
         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
@@ skipping 87 matching lines @@
       { "OriginLastAccessIndex",
         kOriginLastAccessTable,
         "(origin, last_access_time)",
         false },
     };
 
     ASSERT_TRUE(OpenDatabase(db.get(), kDbFile));
     EXPECT_TRUE(QuotaDatabase::CreateSchema(
             db.get(), meta_table.get(),
             kCurrentVersion, kCompatibleVersion,
-            kTables, ARRAYSIZE_UNSAFE(kTables),
-            kIndexes, ARRAYSIZE_UNSAFE(kIndexes)));
+            kTables, arraysize(kTables),
+            kIndexes, arraysize(kIndexes)));
 
     // V2 and V3 QuotaTable are compatible, so we can simply use
     // AssignQuotaTable to poplulate v2 database here.
     db->BeginTransaction();
     AssignQuotaTable(db.get(), entries, entries + entries_size);
     db->CommitTransaction();
   }
 
   base::MessageLoop message_loop_;
 };
@@ skipping 76 matching lines @@
 }
 
 TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
   DumpOriginInfoTable(kDbFile);
   DumpOriginInfoTable(base::FilePath());
 }
 }  // namespace content