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
LazyOpen(const base::FilePath & kDbFile)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
UpgradeSchemaV2toV3(const base::FilePath & 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),
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
HostQuota(const base::FilePath & kDbFile)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, "a));
81 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, "a));
82
83 // Insert quota for temporary.
84 EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota1));
85 EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a));
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, "a));
91 EXPECT_EQ(kQuota2, quota);
92
93 // Quota for persistent must not be updated.
94 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, "a));
95
96 // Delete temporary storage quota.
97 EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary));
98 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a));
99 }
100
GlobalQuota(const base::FilePath & kDbFile)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
OriginLastAccessTimeLRU(const base::FilePath & kDbFile)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
OriginLastModifiedSince(const base::FilePath & kDbFile)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
RegisterInitialOriginInfo(const base::FilePath & kDbFile)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>
EntryVerifiercontent::QuotaDatabaseTest::EntryVerifier323 EntryVerifier(Iterator itr, Iterator end)
324 : table(itr, end) {}
325
Runcontent::QuotaDatabaseTest::EntryVerifier326 bool Run(const EntryType& entry) {
327 EXPECT_EQ(1u, table.erase(entry));
328 return true;
329 }
330 };
331
DumpQuotaTable(const base::FilePath & kDbFile)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
DumpOriginInfoTable(const base::FilePath & kDbFile)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>
AssignQuotaTable(sql::Connection * db,Iterator itr,Iterator end)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>
AssignOriginInfoTable(sql::Connection * db,Iterator itr,Iterator end)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
OpenDatabase(sql::Connection * db,const base::FilePath & kDbFile)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.
CreateV2Database(const base::FilePath & kDbFile,const QuotaTableEntry * entries,size_t entries_size)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
TEST_F(QuotaDatabaseTest,LazyOpen)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
TEST_F(QuotaDatabaseTest,UpgradeSchema)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
TEST_F(QuotaDatabaseTest,HostQuota)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
TEST_F(QuotaDatabaseTest,GlobalQuota)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
TEST_F(QuotaDatabaseTest,OriginLastAccessTimeLRU)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
TEST_F(QuotaDatabaseTest,OriginLastModifiedSince)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
TEST_F(QuotaDatabaseTest,BootstrapFlag)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
TEST_F(QuotaDatabaseTest,RegisterInitialOriginInfo)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
TEST_F(QuotaDatabaseTest,DumpQuotaTable)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
TEST_F(QuotaDatabaseTest,DumpOriginInfoTable)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
568