src/webkit/browser/quota/quota_database_unittest.cc

   1 // Copyright 2013 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/file_util.h"
  12 #include "base/files/scoped_temp_dir.h"
  13 #include "base/message_loop/message_loop.h"
  14 #include "sql/connection.h"
  15 #include "sql/meta_table.h"
  16 #include "sql/statement.h"
  17 #include "sql/transaction.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "url/gurl.h"
  20 #include "webkit/browser/quota/mock_special_storage_policy.h"
  21 #include "webkit/browser/quota/quota_database.h"
  22
  23 namespace quota {
  24 namespace {
  25
  26 const base::Time kZeroTime;
  27
  28 }  // namespace
  29
  30 class QuotaDatabaseTest : public testing::Test {
  31  protected:
  32   typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
  33   typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
  34   typedef QuotaDatabase::OriginInfoTableCallback
  35       OriginInfoTableCallback;
  36
  37   void LazyOpen(const base::FilePath& kDbFile) {
  38     QuotaDatabase db(kDbFile);
  39     EXPECT_FALSE(db.LazyOpen(false));
  40     ASSERT_TRUE(db.LazyOpen(true));
  41     EXPECT_TRUE(db.db_.get());
  42     EXPECT_TRUE(kDbFile.empty() || base::PathExists(kDbFile));
  43   }
  44
  45   void UpgradeSchemaV2toV3(const base::FilePath& kDbFile) {
  46     const QuotaTableEntry entries[] = {
  47       QuotaTableEntry("a", kStorageTypeTemporary,  1),
  48       QuotaTableEntry("b", kStorageTypeTemporary,  2),
  49       QuotaTableEntry("c", kStorageTypePersistent, 3),
  50     };
  51
  52     CreateV2Database(kDbFile, entries, ARRAYSIZE_UNSAFE(entries));
  53
  54     QuotaDatabase db(kDbFile);
  55     EXPECT_TRUE(db.LazyOpen(true));
  56     EXPECT_TRUE(db.db_.get());
  57
  58     typedef EntryVerifier<QuotaTableEntry> Verifier;
  59     Verifier verifier(entries, entries + ARRAYSIZE_UNSAFE(entries));
  60     EXPECT_TRUE(db.DumpQuotaTable(
  61         new QuotaTableCallback(
  62             base::Bind(&Verifier::Run,
  63                        base::Unretained(&verifier)))));
  64     EXPECT_TRUE(verifier.table.empty());
  65   }
  66
  67   void HostQuota(const base::FilePath& kDbFile) {
  68     QuotaDatabase db(kDbFile);
  69     ASSERT_TRUE(db.LazyOpen(true));
  70
  71     const char* kHost = "foo.com";
  72     const int kQuota1 = 13579;
  73     const int kQuota2 = kQuota1 + 1024;
  74
  75     int64 quota = -1;
  76     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  77     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
  78
  79     // Insert quota for temporary.
  80     EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota1));
  81     EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  82     EXPECT_EQ(kQuota1, quota);
  83
  84     // Update quota for temporary.
  85     EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota2));
  86     EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  87     EXPECT_EQ(kQuota2, quota);
  88
  89     // Quota for persistent must not be updated.
  90     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
  91
  92     // Delete temporary storage quota.
  93     EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary));
  94     EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
  95   }
  96
  97   void GlobalQuota(const base::FilePath& kDbFile) {
  98     QuotaDatabase db(kDbFile);
  99     ASSERT_TRUE(db.LazyOpen(true));
 100
 101     const char* kTempQuotaKey = QuotaDatabase::kTemporaryQuotaOverrideKey;
 102     const char* kAvailSpaceKey = QuotaDatabase::kDesiredAvailableSpaceKey;
 103
 104     int64 value = 0;
 105     const int64 kValue1 = 456;
 106     const int64 kValue2 = 123000;
 107     EXPECT_FALSE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
 108     EXPECT_FALSE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 109
 110     EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue1));
 111     EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
 112     EXPECT_EQ(kValue1, value);
 113
 114     EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue2));
 115     EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
 116     EXPECT_EQ(kValue2, value);
 117
 118     EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue1));
 119     EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 120     EXPECT_EQ(kValue1, value);
 121
 122     EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue2));
 123     EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
 124     EXPECT_EQ(kValue2, value);
 125   }
 126
 127   void OriginLastAccessTimeLRU(const base::FilePath& kDbFile) {
 128     QuotaDatabase db(kDbFile);
 129     ASSERT_TRUE(db.LazyOpen(true));
 130
 131     std::set<GURL> exceptions;
 132     GURL origin;
 133     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 134                                 NULL, &origin));
 135     EXPECT_TRUE(origin.is_empty());
 136
 137     const GURL kOrigin1("http://a/");
 138     const GURL kOrigin2("http://b/");
 139     const GURL kOrigin3("http://c/");
 140     const GURL kOrigin4("http://p/");
 141
 142     // Adding three temporary storages, and
 143     EXPECT_TRUE(db.SetOriginLastAccessTime(
 144         kOrigin1, kStorageTypeTemporary, base::Time::FromInternalValue(10)));
 145     EXPECT_TRUE(db.SetOriginLastAccessTime(
 146         kOrigin2, kStorageTypeTemporary, base::Time::FromInternalValue(20)));
 147     EXPECT_TRUE(db.SetOriginLastAccessTime(
 148         kOrigin3, kStorageTypeTemporary, base::Time::FromInternalValue(30)));
 149
 150     // one persistent.
 151     EXPECT_TRUE(db.SetOriginLastAccessTime(
 152         kOrigin4, kStorageTypePersistent, base::Time::FromInternalValue(40)));
 153
 154     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 155                                 NULL, &origin));
 156     EXPECT_EQ(kOrigin1.spec(), origin.spec());
 157
 158     // Test that unlimited origins are exluded from eviction, but
 159     // protected origins are not excluded.
 160     scoped_refptr<MockSpecialStoragePolicy> policy(
 161         new MockSpecialStoragePolicy);
 162     policy->AddUnlimited(kOrigin1);
 163     policy->AddProtected(kOrigin2);
 164     EXPECT_TRUE(db.GetLRUOrigin(
 165         kStorageTypeTemporary, exceptions, policy.get(), &origin));
 166     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 167
 168     exceptions.insert(kOrigin1);
 169     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 170                                 NULL, &origin));
 171     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 172
 173     exceptions.insert(kOrigin2);
 174     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 175                                 NULL, &origin));
 176     EXPECT_EQ(kOrigin3.spec(), origin.spec());
 177
 178     exceptions.insert(kOrigin3);
 179     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 180                                 NULL, &origin));
 181     EXPECT_TRUE(origin.is_empty());
 182
 183     EXPECT_TRUE(db.SetOriginLastAccessTime(
 184         kOrigin1, kStorageTypeTemporary, base::Time::Now()));
 185
 186     // Delete origin/type last access time information.
 187     EXPECT_TRUE(db.DeleteOriginInfo(kOrigin3, kStorageTypeTemporary));
 188
 189     // Querying again to see if the deletion has worked.
 190     exceptions.clear();
 191     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 192                                 NULL, &origin));
 193     EXPECT_EQ(kOrigin2.spec(), origin.spec());
 194
 195     exceptions.insert(kOrigin1);
 196     exceptions.insert(kOrigin2);
 197     EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
 198                                 NULL, &origin));
 199     EXPECT_TRUE(origin.is_empty());
 200   }
 201
 202   void OriginLastModifiedSince(const base::FilePath& kDbFile) {
 203     QuotaDatabase db(kDbFile);
 204     ASSERT_TRUE(db.LazyOpen(true));
 205
 206     std::set<GURL> origins;
 207     EXPECT_TRUE(db.GetOriginsModifiedSince(
 208         kStorageTypeTemporary, &origins, base::Time()));
 209     EXPECT_TRUE(origins.empty());
 210
 211     const GURL kOrigin1("http://a/");
 212     const GURL kOrigin2("http://b/");
 213     const GURL kOrigin3("http://c/");
 214
 215     // Report last mod time for the test origins.
 216     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 217         kOrigin1, kStorageTypeTemporary, base::Time::FromInternalValue(0)));
 218     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 219         kOrigin2, kStorageTypeTemporary, base::Time::FromInternalValue(10)));
 220     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 221         kOrigin3, kStorageTypeTemporary, base::Time::FromInternalValue(20)));
 222
 223     EXPECT_TRUE(db.GetOriginsModifiedSince(
 224         kStorageTypeTemporary, &origins, base::Time()));
 225     EXPECT_EQ(3U, origins.size());
 226     EXPECT_EQ(1U, origins.count(kOrigin1));
 227     EXPECT_EQ(1U, origins.count(kOrigin2));
 228     EXPECT_EQ(1U, origins.count(kOrigin3));
 229
 230     EXPECT_TRUE(db.GetOriginsModifiedSince(
 231         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(5)));
 232     EXPECT_EQ(2U, origins.size());
 233     EXPECT_EQ(0U, origins.count(kOrigin1));
 234     EXPECT_EQ(1U, origins.count(kOrigin2));
 235     EXPECT_EQ(1U, origins.count(kOrigin3));
 236
 237     EXPECT_TRUE(db.GetOriginsModifiedSince(
 238         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(15)));
 239     EXPECT_EQ(1U, origins.size());
 240     EXPECT_EQ(0U, origins.count(kOrigin1));
 241     EXPECT_EQ(0U, origins.count(kOrigin2));
 242     EXPECT_EQ(1U, origins.count(kOrigin3));
 243
 244     EXPECT_TRUE(db.GetOriginsModifiedSince(
 245         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(25)));
 246     EXPECT_TRUE(origins.empty());
 247
 248     // Update origin1's mod time but for persistent storage.
 249     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 250         kOrigin1, kStorageTypePersistent, base::Time::FromInternalValue(30)));
 251
 252     // Must have no effects on temporary origins info.
 253     EXPECT_TRUE(db.GetOriginsModifiedSince(
 254         kStorageTypeTemporary, &origins, base::Time::FromInternalValue(5)));
 255     EXPECT_EQ(2U, origins.size());
 256     EXPECT_EQ(0U, origins.count(kOrigin1));
 257     EXPECT_EQ(1U, origins.count(kOrigin2));
 258     EXPECT_EQ(1U, origins.count(kOrigin3));
 259
 260     // One more update for persistent origin2.
 261     EXPECT_TRUE(db.SetOriginLastModifiedTime(
 262         kOrigin2, kStorageTypePersistent, base::Time::FromInternalValue(40)));
 263
 264     EXPECT_TRUE(db.GetOriginsModifiedSince(
 265         kStorageTypePersistent, &origins, base::Time::FromInternalValue(25)));
 266     EXPECT_EQ(2U, origins.size());
 267     EXPECT_EQ(1U, origins.count(kOrigin1));
 268     EXPECT_EQ(1U, origins.count(kOrigin2));
 269     EXPECT_EQ(0U, origins.count(kOrigin3));
 270
 271     EXPECT_TRUE(db.GetOriginsModifiedSince(
 272         kStorageTypePersistent, &origins, base::Time::FromInternalValue(35)));
 273     EXPECT_EQ(1U, origins.size());
 274     EXPECT_EQ(0U, origins.count(kOrigin1));
 275     EXPECT_EQ(1U, origins.count(kOrigin2));
 276     EXPECT_EQ(0U, origins.count(kOrigin3));
 277   }
 278
 279   void RegisterInitialOriginInfo(const base::FilePath& kDbFile) {
 280     QuotaDatabase db(kDbFile);
 281
 282     const GURL kOrigins[] = {
 283       GURL("http://a/"),
 284       GURL("http://b/"),
 285       GURL("http://c/") };
 286     std::set<GURL> origins(kOrigins, kOrigins + ARRAYSIZE_UNSAFE(kOrigins));
 287
 288     EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 289
 290     int used_count = -1;
 291     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
 292                                        kStorageTypeTemporary,
 293                                        &used_count));
 294     EXPECT_EQ(0, used_count);
 295
 296     EXPECT_TRUE(db.SetOriginLastAccessTime(
 297         GURL("http://a/"), kStorageTypeTemporary,
 298         base::Time::FromDoubleT(1.0)));
 299     used_count = -1;
 300     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
 301                                        kStorageTypeTemporary,
 302                                        &used_count));
 303     EXPECT_EQ(1, used_count);
 304
 305     EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
 306
 307     used_count = -1;
 308     EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
 309                                        kStorageTypeTemporary,
 310                                        &used_count));
 311     EXPECT_EQ(1, used_count);
 312   }
 313
 314   template <typename EntryType>
 315   struct EntryVerifier {
 316     std::set<EntryType> table;
 317
 318     template <typename Iterator>
 319     EntryVerifier(Iterator itr, Iterator end)
 320         : table(itr, end) {}
 321
 322     bool Run(const EntryType& entry) {
 323       EXPECT_EQ(1u, table.erase(entry));
 324       return true;
 325     }
 326   };
 327
 328   void DumpQuotaTable(const base::FilePath& kDbFile) {
 329     QuotaTableEntry kTableEntries[] = {
 330       QuotaTableEntry("http://go/", kStorageTypeTemporary, 1),
 331       QuotaTableEntry("http://oo/", kStorageTypeTemporary, 2),
 332       QuotaTableEntry("http://gle/", kStorageTypePersistent, 3)
 333     };
 334     QuotaTableEntry* begin = kTableEntries;
 335     QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
 336
 337     QuotaDatabase db(kDbFile);
 338     EXPECT_TRUE(db.LazyOpen(true));
 339     AssignQuotaTable(db.db_.get(), begin, end);
 340     db.Commit();
 341
 342     typedef EntryVerifier<QuotaTableEntry> Verifier;
 343     Verifier verifier(begin, end);
 344     EXPECT_TRUE(db.DumpQuotaTable(
 345         new QuotaTableCallback(
 346             base::Bind(&Verifier::Run,
 347                        base::Unretained(&verifier)))));
 348     EXPECT_TRUE(verifier.table.empty());
 349   }
 350
 351   void DumpOriginInfoTable(const base::FilePath& kDbFile) {
 352     base::Time now(base::Time::Now());
 353     typedef QuotaDatabase::OriginInfoTableEntry Entry;
 354     Entry kTableEntries[] = {
 355       Entry(GURL("http://go/"), kStorageTypeTemporary, 2147483647, now, now),
 356       Entry(GURL("http://oo/"), kStorageTypeTemporary, 0, now, now),
 357       Entry(GURL("http://gle/"), kStorageTypeTemporary, 1, now, now),
 358     };
 359     Entry* begin = kTableEntries;
 360     Entry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
 361
 362     QuotaDatabase db(kDbFile);
 363     EXPECT_TRUE(db.LazyOpen(true));
 364     AssignOriginInfoTable(db.db_.get(), begin, end);
 365     db.Commit();
 366
 367     typedef EntryVerifier<Entry> Verifier;
 368     Verifier verifier(begin, end);
 369     EXPECT_TRUE(db.DumpOriginInfoTable(
 370         new OriginInfoTableCallback(
 371             base::Bind(&Verifier::Run,
 372                        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 (!file_util::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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 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("quota_manager.db");
 564   DumpOriginInfoTable(kDbFile);
 565   DumpOriginInfoTable(base::FilePath());
 566 }
 567 }  // namespace quota