Add FilePath to base namespace.

webkit/quota/quota_database_unittest.cc

 // Copyright (c) 2012 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 28 matching lines @@
 
 }  // namespace
 
 class QuotaDatabaseTest : public testing::Test {
  protected:
   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
   typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
   typedef QuotaDatabase::OriginInfoTableCallback
       OriginInfoTableCallback;
 
-  void LazyOpen(const FilePath& kDbFile) {
+  void LazyOpen(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     EXPECT_FALSE(db.LazyOpen(false));
     ASSERT_TRUE(db.LazyOpen(true));
     EXPECT_TRUE(db.db_.get());
     EXPECT_TRUE(kDbFile.empty() || file_util::PathExists(kDbFile));
   }
 
-  void UpgradeSchemaV2toV3(const FilePath& 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));
 
     QuotaDatabase db(kDbFile);
     EXPECT_TRUE(db.LazyOpen(true));
     EXPECT_TRUE(db.db_.get());
 
     typedef EntryVerifier<QuotaTableEntry> Verifier;
     Verifier verifier(entries, entries + ARRAYSIZE_UNSAFE(entries));
     EXPECT_TRUE(db.DumpQuotaTable(
         new QuotaTableCallback(
             base::Bind(&Verifier::Run,
                        base::Unretained(&verifier)))));
     EXPECT_TRUE(verifier.table.empty());
   }
 
-  void HostQuota(const FilePath& kDbFile) {
+  void HostQuota(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     ASSERT_TRUE(db.LazyOpen(true));
 
     const char* kHost = "foo.com";
     const int kQuota1 = 13579;
     const int kQuota2 = kQuota1 + 1024;
 
     int64 quota = -1;
     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
 
     // Insert quota for temporary.
     EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota1));
     EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
     EXPECT_EQ(kQuota1, quota);
 
     // Update quota for temporary.
     EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota2));
     EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
     EXPECT_EQ(kQuota2, quota);
 
     // Quota for persistent must not be updated.
     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
 
     // Delete temporary storage quota.
     EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary));
     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
   }
 
-  void GlobalQuota(const FilePath& kDbFile) {
+  void GlobalQuota(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     ASSERT_TRUE(db.LazyOpen(true));
 
     const char* kTempQuotaKey = QuotaDatabase::kTemporaryQuotaOverrideKey;
     const char* kAvailSpaceKey = QuotaDatabase::kDesiredAvailableSpaceKey;
 
     int64 value = 0;
     const int64 kValue1 = 456;
     const int64 kValue2 = 123000;
     EXPECT_FALSE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
     EXPECT_FALSE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 
     EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue1));
     EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
     EXPECT_EQ(kValue1, value);
 
     EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue2));
     EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
     EXPECT_EQ(kValue2, value);
 
     EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue1));
     EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
     EXPECT_EQ(kValue1, value);
 
     EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue2));
     EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
     EXPECT_EQ(kValue2, value);
   }
 
-  void OriginLastAccessTimeLRU(const FilePath& kDbFile) {
+  void OriginLastAccessTimeLRU(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     ASSERT_TRUE(db.LazyOpen(true));
 
     std::set<GURL> exceptions;
     GURL origin;
     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
                                 NULL, &origin));
     EXPECT_TRUE(origin.is_empty());
 
     const GURL kOrigin1("http://a/");
@@ skipping 54 matching lines @@
                                 NULL, &origin));
     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 
     exceptions.insert(kOrigin1);
     exceptions.insert(kOrigin2);
     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
                                 NULL, &origin));
     EXPECT_TRUE(origin.is_empty());
   }
 
-  void OriginLastModifiedSince(const FilePath& kDbFile) {
+  void OriginLastModifiedSince(const base::FilePath& kDbFile) {
     QuotaDatabase db(kDbFile);
     ASSERT_TRUE(db.LazyOpen(true));
 
     std::set<GURL> origins;
     EXPECT_TRUE(db.GetOriginsModifiedSince(
         kStorageTypeTemporary, &origins, base::Time()));
     EXPECT_TRUE(origins.empty());
 
     const GURL kOrigin1("http://a/");
     const GURL kOrigin2("http://b/");
@@ skipping 56 matching lines @@
     EXPECT_EQ(0U, origins.count(kOrigin3));
 
     EXPECT_TRUE(db.GetOriginsModifiedSince(
         kStorageTypePersistent, &origins, base::Time::FromInternalValue(35)));
     EXPECT_EQ(1U, origins.size());
     EXPECT_EQ(0U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(0U, origins.count(kOrigin3));
   }
 
-  void RegisterInitialOriginInfo(const FilePath& kDbFile) {
+  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));
 
     EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 
@@ skipping 28 matching lines @@
     template <typename Iterator>
     EntryVerifier(Iterator itr, Iterator end)
         : table(itr, end) {}
 
     bool Run(const EntryType& entry) {
       EXPECT_EQ(1u, table.erase(entry));
       return true;
     }
   };
 
-  void DumpQuotaTable(const FilePath& kDbFile) {
+  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);
 
     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(
         new QuotaTableCallback(
             base::Bind(&Verifier::Run,
                        base::Unretained(&verifier)))));
     EXPECT_TRUE(verifier.table.empty());
   }
 
-  void DumpOriginInfoTable(const FilePath& kDbFile) {
+  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);
 
@@ skipping 45 matching lines @@
 
       statement.BindString(0, itr->origin.spec());
       statement.BindInt(1, static_cast<int>(itr->type));
       statement.BindInt(2, itr->used_count);
       statement.BindInt64(3, itr->last_access_time.ToInternalValue());
       statement.BindInt64(4, itr->last_modified_time.ToInternalValue());
       EXPECT_TRUE(statement.Run());
     }
   }
 
-  bool OpenDatabase(sql::Connection* db, const FilePath& kDbFile) {
+  bool OpenDatabase(sql::Connection* db, const base::FilePath& kDbFile) {
     if (kDbFile.empty()) {
       return db->OpenInMemory();
     }
     if (!file_util::CreateDirectory(kDbFile.DirName()))
       return false;
     if (!db->Open(kDbFile))
       return false;
     db->Preload();
     return true;
   }
 
   // Create V2 database and populate some data.
   void CreateV2Database(
-      const FilePath& kDbFile,
+      const base::FilePath& kDbFile,
       const QuotaTableEntry* entries,
       size_t entries_size) {
     scoped_ptr<sql::Connection> db(new sql::Connection);
     scoped_ptr<sql::MetaTable> meta_table(new sql::MetaTable);
 
     // V2 schema definitions.
     static const int kCurrentVersion = 2;
     static const int kCompatibleVersion = 2;
     static const char kHostQuotaTable[] = "HostQuotaTable";
     static const char kOriginLastAccessTable[] = "OriginLastAccessTable";
@@ skipping 34 matching lines @@
     AssignQuotaTable(db.get(), entries, entries + entries_size);
     db->CommitTransaction();
   }
 
   MessageLoop message_loop_;
 };
 
 TEST_F(QuotaDatabaseTest, LazyOpen) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   LazyOpen(kDbFile);
-  LazyOpen(FilePath());
+  LazyOpen(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, UpgradeSchema) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   UpgradeSchemaV2toV3(kDbFile);
 }
 
 TEST_F(QuotaDatabaseTest, HostQuota) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   HostQuota(kDbFile);
-  HostQuota(FilePath());
+  HostQuota(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, GlobalQuota) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   GlobalQuota(kDbFile);
-  GlobalQuota(FilePath());
+  GlobalQuota(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, OriginLastAccessTimeLRU) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   OriginLastAccessTimeLRU(kDbFile);
-  OriginLastAccessTimeLRU(FilePath());
+  OriginLastAccessTimeLRU(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, OriginLastModifiedSince) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   OriginLastModifiedSince(kDbFile);
-  OriginLastModifiedSince(FilePath());
+  OriginLastModifiedSince(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, BootstrapFlag) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   QuotaDatabase db(kDbFile);
 
   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
   EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(true));
   EXPECT_TRUE(db.IsOriginDatabaseBootstrapped());
   EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(false));
   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
 }
 
 TEST_F(QuotaDatabaseTest, RegisterInitialOriginInfo) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   RegisterInitialOriginInfo(kDbFile);
-  RegisterInitialOriginInfo(FilePath());
+  RegisterInitialOriginInfo(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, DumpQuotaTable) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   DumpQuotaTable(kDbFile);
-  DumpQuotaTable(FilePath());
+  DumpQuotaTable(base::FilePath());
 }
 
 TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) {
   base::ScopedTempDir data_dir;
   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
-  const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
+  const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db");
   DumpOriginInfoTable(kDbFile);
-  DumpOriginInfoTable(FilePath());
+  DumpOriginInfoTable(base::FilePath());
 }
 }  // namespace quota