content/browser/quota/quota_database_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6 #include <iterator>
   7 #include <set>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/files/file_util.h"
  12 #include "base/files/scoped_temp_dir.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "content/public/test/mock_special_storage_policy.h"
  15 #include "sql/connection.h"
  16 #include "sql/meta_table.h"
  17 #include "sql/statement.h"
  18 #include "sql/transaction.h"
  19 #include "storage/browser/quota/quota_database.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "url/gurl.h"
  22
  23 using storage::kStorageTypePersistent;
  24 using storage::kStorageTypeTemporary;
  25 using storage::QuotaDatabase;
  26
  27 namespace content {
  28 namespace {
  29
  30 const base::Time kZeroTime;
  31
  32 const char kDBFileName[] = "quota_manager.db";
  33
  34 }  // namespace
  35
  36 class QuotaDatabaseTest : public testing::Test {
  37  protected:
  38   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
  39   typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
  40   typedef QuotaDatabase::OriginInfoTableCallback
  41       OriginInfoTableCallback;
  42
  43   void LazyOpen(const base::FilePath& kDbFile) {
  44     QuotaDatabase db(kDbFile);
  45     EXPECT_FALSE(db.LazyOpen(false));
  46     ASSERT_TRUE(db.LazyOpen(true));
  47     EXPECT_TRUE(db.db_.get());
  48     EXPECT_TRUE(kDbFile.empty() || base::PathExists(kDbFile));
  49   }
  50
  51   void UpgradeSchemaV2toV3(const base::FilePath& kDbFile) {
  52     const QuotaTableEntry entries[] = {
  53       QuotaTableEntry("a", kStorageTypeTemporary,  1),
  54       QuotaTableEntry("b", kStorageTypeTemporary,  2),
  55       QuotaTableEntry("c", kStorageTypePersistent, 3),
  56     };
  57
  58     CreateV2Database(kDbFile, entries, ARRAYSIZE_UNSAFE(entries));
  59
  60     QuotaDatabase db(kDbFile);
  61     EXPECT_TRUE(db.LazyOpen(true));
  62     EXPECT_TRUE(db.db_.get());
  63
  64     typedef EntryVerifier<QuotaTableEntry> Verifier;
  65     Verifier verifier(entries, entries + ARRAYSIZE_UNSAFE(entries));
  66     EXPECT_TRUE(db.DumpQuotaTable(
  67         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
  68     EXPECT_TRUE(verifier.table.empty());
  69   }
  70
  71   void HostQuota(const base::FilePath& kDbFile) {
  72     QuotaDatabase db(kDbFile);
  73     ASSERT_TRUE(db.LazyOpen(true));
  74
  75     const char* kHost = "foo.com";
  76     const int kQuota1 = 13579;
  77     const int kQuota2 = kQuota1 + 1024;
  78
  79     int64 quota = -1;
  80     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  81     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
  82
  83     // Insert quota for temporary.
  84     EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota1));
  85     EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  86     EXPECT_EQ(kQuota1, quota);
  87
  88     // Update quota for temporary.
  89     EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota2));
  90     EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  91     EXPECT_EQ(kQuota2, quota);
  92
  93     // Quota for persistent must not be updated.
  94     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
  95
  96     // Delete temporary storage quota.
  97     EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary));
  98     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  99   }
 100
 101   void GlobalQuota(const base::FilePath& kDbFile) {
 102     QuotaDatabase db(kDbFile);
 103     ASSERT_TRUE(db.LazyOpen(true));
 104
 105     const char* kTempQuotaKey = QuotaDatabase::kTemporaryQuotaOverrideKey;
 106     const char* kAvailSpaceKey = QuotaDatabase::kDesiredAvailableSpaceKey;
 107
 108     int64 value = 0;
 109     const int64 kValue1 = 456;
 110     const int64 kValue2 = 123000;
 111     EXPECT_FALSE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
 112     EXPECT_FALSE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 113
 114     EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue1));
 115     EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
 116     EXPECT_EQ(kValue1, value);
 117
 118     EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue2));
 119     EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
 120     EXPECT_EQ(kValue2, value);
 121
 122     EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue1));
 123     EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 124     EXPECT_EQ(kValue1, value);
 125
 126     EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue2));
 127     EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 128     EXPECT_EQ(kValue2, value);
 129   }
 130
 131   void OriginLastAccessTimeLRU(const base::FilePath& kDbFile) {
 132     QuotaDatabase db(kDbFile);
 133     ASSERT_TRUE(db.LazyOpen(true));
 134
 135     std::set<GURL> exceptions;
 136     GURL origin;
 137     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 138                                 NULL, &origin));
 139     EXPECT_TRUE(origin.is_empty());
 140
 141     const GURL kOrigin1("http://a/");
 142     const GURL kOrigin2("http://b/");
 143     const GURL kOrigin3("http://c/");
 144     const GURL kOrigin4("http://p/");
 145
 146     // Adding three temporary storages, and
 147     EXPECT_TRUE(db.SetOriginLastAccessTime(
 148         kOrigin1, kStorageTypeTemporary, base::Time::FromInternalValue(10)));
 149     EXPECT_TRUE(db.SetOriginLastAccessTime(
 150         kOrigin2, kStorageTypeTemporary, base::Time::FromInternalValue(20)));
 151     EXPECT_TRUE(db.SetOriginLastAccessTime(
 152         kOrigin3, kStorageTypeTemporary, base::Time::FromInternalValue(30)));
 153
 154     // one persistent.
 155     EXPECT_TRUE(db.SetOriginLastAccessTime(
 156         kOrigin4, kStorageTypePersistent, base::Time::FromInternalValue(40)));
 157
 158     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 159                                 NULL, &origin));
 160     EXPECT_EQ(kOrigin1.spec(), origin.spec());
 161
 162     // Test that unlimited origins are exluded from eviction, but
 163     // protected origins are not excluded.
 164     scoped_refptr<MockSpecialStoragePolicy> policy(
 165         new MockSpecialStoragePolicy);
 166     policy->AddUnlimited(kOrigin1);
 167     policy->AddProtected(kOrigin2);
 168     EXPECT_TRUE(db.GetLRUOrigin(
 169         kStorageTypeTemporary, exceptions, policy.get(), &origin));
 170     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 171
 172     exceptions.insert(kOrigin1);
 173     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 174                                 NULL, &origin));
 175     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 176
 177     exceptions.insert(kOrigin2);
 178     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 179                                 NULL, &origin));
 180     EXPECT_EQ(kOrigin3.spec(), origin.spec());
 181
 182     exceptions.insert(kOrigin3);
 183     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 184                                 NULL, &origin));
 185     EXPECT_TRUE(origin.is_empty());
 186
 187     EXPECT_TRUE(db.SetOriginLastAccessTime(
 188         kOrigin1, kStorageTypeTemporary, base::Time::Now()));
 189
 190     // Delete origin/type last access time information.
 191     EXPECT_TRUE(db.DeleteOriginInfo(kOrigin3, kStorageTypeTemporary));
 192
 193     // Querying again to see if the deletion has worked.
 194     exceptions.clear();
 195     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 196                                 NULL, &origin));
 197     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 198
 199     exceptions.insert(kOrigin1);
 200     exceptions.insert(kOrigin2);
 201     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 202                                 NULL, &origin));
 203     EXPECT_TRUE(origin.is_empty());
 204   }
 205
 206   void OriginLastModifiedSince(const base::FilePath& kDbFile) {
 207     QuotaDatabase db(kDbFile);
 208     ASSERT_TRUE(db.LazyOpen(true));
 209
 210     std::set<GURL> origins;
 211     EXPECT_TRUE(db.GetOriginsModifiedSince(
 212         kStorageTypeTemporary, &origins, base::Time()));
 213     EXPECT_TRUE(origins.empty());
 214
 215     const GURL kOrigin1("http://a/");
 216     const GURL kOrigin2("http://b/");
 217     const GURL kOrigin3("http://c/");
 218
 219     // Report last mod time for the test origins.
 220     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 221         kOrigin1, kStorageTypeTemporary, base::Time::FromInternalValue(0)));
 222     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 223         kOrigin2, kStorageTypeTemporary, base::Time::FromInternalValue(10)));
 224     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 225         kOrigin3, kStorageTypeTemporary, base::Time::FromInternalValue(20)));
 226
 227     EXPECT_TRUE(db.GetOriginsModifiedSince(
 228         kStorageTypeTemporary, &origins, base::Time()));
 229     EXPECT_EQ(3U, origins.size());
 230     EXPECT_EQ(1U, origins.count(kOrigin1));
 231     EXPECT_EQ(1U, origins.count(kOrigin2));
 232     EXPECT_EQ(1U, origins.count(kOrigin3));
 233
 234     EXPECT_TRUE(db.GetOriginsModifiedSince(
 235         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(5)));
 236     EXPECT_EQ(2U, origins.size());
 237     EXPECT_EQ(0U, origins.count(kOrigin1));
 238     EXPECT_EQ(1U, origins.count(kOrigin2));
 239     EXPECT_EQ(1U, origins.count(kOrigin3));
 240
 241     EXPECT_TRUE(db.GetOriginsModifiedSince(
 242         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(15)));
 243     EXPECT_EQ(1U, origins.size());
 244     EXPECT_EQ(0U, origins.count(kOrigin1));
 245     EXPECT_EQ(0U, origins.count(kOrigin2));
 246     EXPECT_EQ(1U, origins.count(kOrigin3));
 247
 248     EXPECT_TRUE(db.GetOriginsModifiedSince(
 249         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(25)));
 250     EXPECT_TRUE(origins.empty());
 251
 252     // Update origin1's mod time but for persistent storage.
 253     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 254         kOrigin1, kStorageTypePersistent, base::Time::FromInternalValue(30)));
 255
 256     // Must have no effects on temporary origins info.
 257     EXPECT_TRUE(db.GetOriginsModifiedSince(
 258         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(5)));
 259     EXPECT_EQ(2U, origins.size());
 260     EXPECT_EQ(0U, origins.count(kOrigin1));
 261     EXPECT_EQ(1U, origins.count(kOrigin2));
 262     EXPECT_EQ(1U, origins.count(kOrigin3));
 263
 264     // One more update for persistent origin2.
 265     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 266         kOrigin2, kStorageTypePersistent, base::Time::FromInternalValue(40)));
 267
 268     EXPECT_TRUE(db.GetOriginsModifiedSince(
 269         kStorageTypePersistent, &origins, base::Time::FromInternalValue(25)));
 270     EXPECT_EQ(2U, origins.size());
 271     EXPECT_EQ(1U, origins.count(kOrigin1));
 272     EXPECT_EQ(1U, origins.count(kOrigin2));
 273     EXPECT_EQ(0U, origins.count(kOrigin3));
 274
 275     EXPECT_TRUE(db.GetOriginsModifiedSince(
 276         kStorageTypePersistent, &origins, base::Time::FromInternalValue(35)));
 277     EXPECT_EQ(1U, origins.size());
 278     EXPECT_EQ(0U, origins.count(kOrigin1));
 279     EXPECT_EQ(1U, origins.count(kOrigin2));
 280     EXPECT_EQ(0U, origins.count(kOrigin3));
 281   }
 282
 283   void RegisterInitialOriginInfo(const base::FilePath& kDbFile) {
 284     QuotaDatabase db(kDbFile);
 285
 286     const GURL kOrigins[] = {
 287       GURL("http://a/"),
 288       GURL("http://b/"),
 289       GURL("http://c/") };
 290     std::set<GURL> origins(kOrigins, kOrigins + ARRAYSIZE_UNSAFE(kOrigins));
 291
 292     EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 293
 294     int used_count = -1;
 295     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
 296                                        kStorageTypeTemporary,
 297                                        &used_count));
 298     EXPECT_EQ(0, used_count);
 299
 300     EXPECT_TRUE(db.SetOriginLastAccessTime(
 301         GURL("http://a/"), kStorageTypeTemporary,
 302         base::Time::FromDoubleT(1.0)));
 303     used_count = -1;
 304     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
 305                                        kStorageTypeTemporary,
 306                                        &used_count));
 307     EXPECT_EQ(1, used_count);
 308
 309     EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 310
 311     used_count = -1;
 312     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
 313                                        kStorageTypeTemporary,
 314                                        &used_count));
 315     EXPECT_EQ(1, used_count);
 316   }
 317
 318   template <typename EntryType>
 319   struct EntryVerifier {
 320     std::set<EntryType> table;
 321
 322     template <typename Iterator>
 323     EntryVerifier(Iterator itr, Iterator end)
 324         : table(itr, end) {}
 325
 326     bool Run(const EntryType& entry) {
 327       EXPECT_EQ(1u, table.erase(entry));
 328       return true;
 329     }
 330   };
 331
 332   void DumpQuotaTable(const base::FilePath& kDbFile) {
 333     QuotaTableEntry kTableEntries[] = {
 334       QuotaTableEntry("http://go/", kStorageTypeTemporary, 1),
 335       QuotaTableEntry("http://oo/", kStorageTypeTemporary, 2),
 336       QuotaTableEntry("http://gle/", kStorageTypePersistent, 3)
 337     };
 338     QuotaTableEntry* begin = kTableEntries;
 339     QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
 340
 341     QuotaDatabase db(kDbFile);
 342     EXPECT_TRUE(db.LazyOpen(true));
 343     AssignQuotaTable(db.db_.get(), begin, end);
 344     db.Commit();
 345
 346     typedef EntryVerifier<QuotaTableEntry> Verifier;
 347     Verifier verifier(begin, end);
 348     EXPECT_TRUE(db.DumpQuotaTable(
 349         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
 350     EXPECT_TRUE(verifier.table.empty());
 351   }
 352
 353   void DumpOriginInfoTable(const base::FilePath& kDbFile) {
 354     base::Time now(base::Time::Now());
 355     typedef QuotaDatabase::OriginInfoTableEntry Entry;
 356     Entry kTableEntries[] = {
 357       Entry(GURL("http://go/"), kStorageTypeTemporary, 2147483647, now, now),
 358       Entry(GURL("http://oo/"), kStorageTypeTemporary, 0, now, now),
 359       Entry(GURL("http://gle/"), kStorageTypeTemporary, 1, now, now),
 360     };
 361     Entry* begin = kTableEntries;
 362     Entry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
 363
 364     QuotaDatabase db(kDbFile);
 365     EXPECT_TRUE(db.LazyOpen(true));
 366     AssignOriginInfoTable(db.db_.get(), begin, end);
 367     db.Commit();
 368
 369     typedef EntryVerifier<Entry> Verifier;
 370     Verifier verifier(begin, end);
 371     EXPECT_TRUE(db.DumpOriginInfoTable(
 372         base::Bind(&Verifier::Run, base::Unretained(&verifier))));
 373     EXPECT_TRUE(verifier.table.empty());
 374   }
 375
 376  private:
 377   template <typename Iterator>
 378   void AssignQuotaTable(sql::Connection* db, Iterator itr, Iterator end) {
 379     ASSERT_NE(db, (sql::Connection*)NULL);
 380     for (; itr != end; ++itr) {
 381       const char* kSql =
 382           "INSERT INTO HostQuotaTable"
 383           " (host, type, quota)"
 384           " VALUES (?, ?, ?)";
 385       sql::Statement statement;
 386       statement.Assign(db->GetCachedStatement(SQL_FROM_HERE, kSql));
 387       ASSERT_TRUE(statement.is_valid());
 388
 389       statement.BindString(0, itr->host);
 390       statement.BindInt(1, static_cast<int>(itr->type));
 391       statement.BindInt64(2, itr->quota);
 392       EXPECT_TRUE(statement.Run());
 393     }
 394   }
 395
 396   template <typename Iterator>
 397   void AssignOriginInfoTable(sql::Connection* db, Iterator itr, Iterator end) {
 398     ASSERT_NE(db, (sql::Connection*)NULL);
 399     for (; itr != end; ++itr) {
 400       const char* kSql =
 401           "INSERT INTO OriginInfoTable"
 402           " (origin, type, used_count, last_access_time, last_modified_time)"
 403           " VALUES (?, ?, ?, ?, ?)";
 404       sql::Statement statement;
 405       statement.Assign(db->GetCachedStatement(SQL_FROM_HERE, kSql));
 406       ASSERT_TRUE(statement.is_valid());
 407
 408       statement.BindString(0, itr->origin.spec());
 409       statement.BindInt(1, static_cast<int>(itr->type));
 410       statement.BindInt(2, itr->used_count);
 411       statement.BindInt64(3, itr->last_access_time.ToInternalValue());
 412       statement.BindInt64(4, itr->last_modified_time.ToInternalValue());
 413       EXPECT_TRUE(statement.Run());
 414     }
 415   }
 416
 417   bool OpenDatabase(sql::Connection* db, const base::FilePath& kDbFile) {
 418     if (kDbFile.empty()) {
 419       return db->OpenInMemory();
 420     }
 421     if (!base::CreateDirectory(kDbFile.DirName()))
 422       return false;
 423     if (!db->Open(kDbFile))
 424       return false;
 425     db->Preload();
 426     return true;
 427   }
 428
 429   // Create V2 database and populate some data.
 430   void CreateV2Database(
 431       const base::FilePath& kDbFile,
 432       const QuotaTableEntry* entries,
 433       size_t entries_size) {
 434     scoped_ptr<sql::Connection> db(new sql::Connection);
 435     scoped_ptr<sql::MetaTable> meta_table(new sql::MetaTable);
 436
 437     // V2 schema definitions.
 438     static const int kCurrentVersion = 2;
 439     static const int kCompatibleVersion = 2;
 440     static const char kHostQuotaTable[] = "HostQuotaTable";
 441     static const char kOriginLastAccessTable[] = "OriginLastAccessTable";
 442     static const QuotaDatabase::TableSchema kTables[] = {
 443       { kHostQuotaTable,
 444         "(host TEXT NOT NULL,"
 445         " type INTEGER NOT NULL,"
 446         " quota INTEGER,"
 447         " UNIQUE(host, type))" },
 448       { kOriginLastAccessTable,
 449         "(origin TEXT NOT NULL,"
 450         " type INTEGER NOT NULL,"
 451         " used_count INTEGER,"
 452         " last_access_time INTEGER,"
 453         " UNIQUE(origin, type))" },
 454     };
 455     static const QuotaDatabase::IndexSchema kIndexes[] = {
 456       { "HostIndex",
 457         kHostQuotaTable,
 458         "(host)",
 459         false },
 460       { "OriginLastAccessIndex",
 461         kOriginLastAccessTable,
 462         "(origin, last_access_time)",
 463         false },
 464     };
 465
 466     ASSERT_TRUE(OpenDatabase(db.get(), kDbFile));
 467     EXPECT_TRUE(QuotaDatabase::CreateSchema(
 468             db.get(), meta_table.get(),
 469             kCurrentVersion, kCompatibleVersion,
 470             kTables, ARRAYSIZE_UNSAFE(kTables),
 471             kIndexes, ARRAYSIZE_UNSAFE(kIndexes)));
 472
 473     // V2 and V3 QuotaTable are compatible, so we can simply use
 474     // AssignQuotaTable to poplulate v2 database here.
 475     db->BeginTransaction();
 476     AssignQuotaTable(db.get(), entries, entries + entries_size);
 477     db->CommitTransaction();
 478   }
 479
 480   base::MessageLoop message_loop_;
 481 };
 482
 483 TEST_F(QuotaDatabaseTest, LazyOpen) {
 484   base::ScopedTempDir data_dir;
 485   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 486   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 487   LazyOpen(kDbFile);
 488   LazyOpen(base::FilePath());
 489 }
 490
 491 TEST_F(QuotaDatabaseTest, UpgradeSchema) {
 492   base::ScopedTempDir data_dir;
 493   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 494   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 495   UpgradeSchemaV2toV3(kDbFile);
 496 }
 497
 498 TEST_F(QuotaDatabaseTest, HostQuota) {
 499   base::ScopedTempDir data_dir;
 500   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 501   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 502   HostQuota(kDbFile);
 503   HostQuota(base::FilePath());
 504 }
 505
 506 TEST_F(QuotaDatabaseTest, GlobalQuota) {
 507   base::ScopedTempDir data_dir;
 508   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 509   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 510   GlobalQuota(kDbFile);
 511   GlobalQuota(base::FilePath());
 512 }
 513
 514 TEST_F(QuotaDatabaseTest, OriginLastAccessTimeLRU) {
 515   base::ScopedTempDir data_dir;
 516   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 517   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 518   OriginLastAccessTimeLRU(kDbFile);
 519   OriginLastAccessTimeLRU(base::FilePath());
 520 }
 521
 522 TEST_F(QuotaDatabaseTest, OriginLastModifiedSince) {
 523   base::ScopedTempDir data_dir;
 524   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 525   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 526   OriginLastModifiedSince(kDbFile);
 527   OriginLastModifiedSince(base::FilePath());
 528 }
 529
 530 TEST_F(QuotaDatabaseTest, BootstrapFlag) {
 531   base::ScopedTempDir data_dir;
 532   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 533
 534   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 535   QuotaDatabase db(kDbFile);
 536
 537   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
 538   EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(true));
 539   EXPECT_TRUE(db.IsOriginDatabaseBootstrapped());
 540   EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(false));
 541   EXPECT_FALSE(db.IsOriginDatabaseBootstrapped());
 542 }
 543
 544 TEST_F(QuotaDatabaseTest, RegisterInitialOriginInfo) {
 545   base::ScopedTempDir data_dir;
 546   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 547   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 548   RegisterInitialOriginInfo(kDbFile);
 549   RegisterInitialOriginInfo(base::FilePath());
 550 }
 551
 552 TEST_F(QuotaDatabaseTest, DumpQuotaTable) {
 553   base::ScopedTempDir data_dir;
 554   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 555   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 556   DumpQuotaTable(kDbFile);
 557   DumpQuotaTable(base::FilePath());
 558 }
 559
 560 TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) {
 561   base::ScopedTempDir data_dir;
 562   ASSERT_TRUE(data_dir.CreateUniqueTempDir());
 563   const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
 564   DumpOriginInfoTable(kDbFile);
 565   DumpOriginInfoTable(base::FilePath());
 566 }
 567 }  // namespace content