Updating trunk VERSION from 2139.0 to 2140.0
[chromium-blink-merge.git] / content / browser / quota / quota_database_unittest.cc
blob4422bdbea3e509aaa927d8db1f3b918f39c6a5d1
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.
5 #include <algorithm>
6 #include <iterator>
7 #include <set>
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 "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 "testing/gtest/include/gtest/gtest.h"
20 #include "url/gurl.h"
21 #include "webkit/browser/quota/quota_database.h"
23 using storage::kStorageTypePersistent;
24 using storage::kStorageTypeTemporary;
25 using storage::QuotaDatabase;
27 namespace content {
28 namespace {
30 const base::Time kZeroTime;
32 const char kDBFileName[] = "quota_manager.db";
34 } // namespace
36 class QuotaDatabaseTest : public testing::Test {
37 protected:
38 typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry;
39 typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback;
40 typedef QuotaDatabase::OriginInfoTableCallback
41 OriginInfoTableCallback;
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));
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),
58 CreateV2Database(kDbFile, entries, ARRAYSIZE_UNSAFE(entries));
60 QuotaDatabase db(kDbFile);
61 EXPECT_TRUE(db.LazyOpen(true));
62 EXPECT_TRUE(db.db_.get());
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());
71 void HostQuota(const base::FilePath& kDbFile) {
72 QuotaDatabase db(kDbFile);
73 ASSERT_TRUE(db.LazyOpen(true));
75 const char* kHost = "foo.com";
76 const int kQuota1 = 13579;
77 const int kQuota2 = kQuota1 + 1024;
79 int64 quota = -1;
80 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
81 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
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);
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);
93 // Quota for persistent must not be updated.
94 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, &quota));
96 // Delete temporary storage quota.
97 EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary));
98 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, &quota));
101 void GlobalQuota(const base::FilePath& kDbFile) {
102 QuotaDatabase db(kDbFile);
103 ASSERT_TRUE(db.LazyOpen(true));
105 const char* kTempQuotaKey = QuotaDatabase::kTemporaryQuotaOverrideKey;
106 const char* kAvailSpaceKey = QuotaDatabase::kDesiredAvailableSpaceKey;
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));
114 EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue1));
115 EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
116 EXPECT_EQ(kValue1, value);
118 EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue2));
119 EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value));
120 EXPECT_EQ(kValue2, value);
122 EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue1));
123 EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
124 EXPECT_EQ(kValue1, value);
126 EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue2));
127 EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value));
128 EXPECT_EQ(kValue2, value);
131 void OriginLastAccessTimeLRU(const base::FilePath& kDbFile) {
132 QuotaDatabase db(kDbFile);
133 ASSERT_TRUE(db.LazyOpen(true));
135 std::set<GURL> exceptions;
136 GURL origin;
137 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
138 NULL, &origin));
139 EXPECT_TRUE(origin.is_empty());
141 const GURL kOrigin1("http://a/");
142 const GURL kOrigin2("http://b/");
143 const GURL kOrigin3("http://c/");
144 const GURL kOrigin4("http://p/");
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)));
154 // one persistent.
155 EXPECT_TRUE(db.SetOriginLastAccessTime(
156 kOrigin4, kStorageTypePersistent, base::Time::FromInternalValue(40)));
158 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
159 NULL, &origin));
160 EXPECT_EQ(kOrigin1.spec(), origin.spec());
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());
172 exceptions.insert(kOrigin1);
173 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
174 NULL, &origin));
175 EXPECT_EQ(kOrigin2.spec(), origin.spec());
177 exceptions.insert(kOrigin2);
178 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
179 NULL, &origin));
180 EXPECT_EQ(kOrigin3.spec(), origin.spec());
182 exceptions.insert(kOrigin3);
183 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
184 NULL, &origin));
185 EXPECT_TRUE(origin.is_empty());
187 EXPECT_TRUE(db.SetOriginLastAccessTime(
188 kOrigin1, kStorageTypeTemporary, base::Time::Now()));
190 // Delete origin/type last access time information.
191 EXPECT_TRUE(db.DeleteOriginInfo(kOrigin3, kStorageTypeTemporary));
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());
199 exceptions.insert(kOrigin1);
200 exceptions.insert(kOrigin2);
201 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions,
202 NULL, &origin));
203 EXPECT_TRUE(origin.is_empty());
206 void OriginLastModifiedSince(const base::FilePath& kDbFile) {
207 QuotaDatabase db(kDbFile);
208 ASSERT_TRUE(db.LazyOpen(true));
210 std::set<GURL> origins;
211 EXPECT_TRUE(db.GetOriginsModifiedSince(
212 kStorageTypeTemporary, &origins, base::Time()));
213 EXPECT_TRUE(origins.empty());
215 const GURL kOrigin1("http://a/");
216 const GURL kOrigin2("http://b/");
217 const GURL kOrigin3("http://c/");
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)));
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));
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));
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));
248 EXPECT_TRUE(db.GetOriginsModifiedSince(
249 kStorageTypeTemporary, &origins, base::Time::FromInternalValue(25)));
250 EXPECT_TRUE(origins.empty());
252 // Update origin1's mod time but for persistent storage.
253 EXPECT_TRUE(db.SetOriginLastModifiedTime(
254 kOrigin1, kStorageTypePersistent, base::Time::FromInternalValue(30)));
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));
264 // One more update for persistent origin2.
265 EXPECT_TRUE(db.SetOriginLastModifiedTime(
266 kOrigin2, kStorageTypePersistent, base::Time::FromInternalValue(40)));
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));
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));
283 void RegisterInitialOriginInfo(const base::FilePath& kDbFile) {
284 QuotaDatabase db(kDbFile);
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));
292 EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
294 int used_count = -1;
295 EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
296 kStorageTypeTemporary,
297 &used_count));
298 EXPECT_EQ(0, used_count);
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);
309 EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary));
311 used_count = -1;
312 EXPECT_TRUE(db.FindOriginUsedCount(GURL("http://a/"),
313 kStorageTypeTemporary,
314 &used_count));
315 EXPECT_EQ(1, used_count);
318 template <typename EntryType>
319 struct EntryVerifier {
320 std::set<EntryType> table;
322 template <typename Iterator>
323 EntryVerifier(Iterator itr, Iterator end)
324 : table(itr, end) {}
326 bool Run(const EntryType& entry) {
327 EXPECT_EQ(1u, table.erase(entry));
328 return true;
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)
338 QuotaTableEntry* begin = kTableEntries;
339 QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
341 QuotaDatabase db(kDbFile);
342 EXPECT_TRUE(db.LazyOpen(true));
343 AssignQuotaTable(db.db_.get(), begin, end);
344 db.Commit();
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());
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),
361 Entry* begin = kTableEntries;
362 Entry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries);
364 QuotaDatabase db(kDbFile);
365 EXPECT_TRUE(db.LazyOpen(true));
366 AssignOriginInfoTable(db.db_.get(), begin, end);
367 db.Commit();
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());
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());
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());
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());
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());
417 bool OpenDatabase(sql::Connection* db, const base::FilePath& kDbFile) {
418 if (kDbFile.empty()) {
419 return db->OpenInMemory();
421 if (!base::CreateDirectory(kDbFile.DirName()))
422 return false;
423 if (!db->Open(kDbFile))
424 return false;
425 db->Preload();
426 return true;
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);
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))" },
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 },
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)));
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();
480 base::MessageLoop message_loop_;
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());
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);
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());
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());
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());
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());
530 TEST_F(QuotaDatabaseTest, BootstrapFlag) {
531 base::ScopedTempDir data_dir;
532 ASSERT_TRUE(data_dir.CreateUniqueTempDir());
534 const base::FilePath kDbFile = data_dir.path().AppendASCII(kDBFileName);
535 QuotaDatabase db(kDbFile);
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());
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());
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());
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());
567 } // namespace content