OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <algorithm> | 5 #include <algorithm> |
6 #include <iterator> | 6 #include <iterator> |
7 #include <set> | 7 #include <set> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/callback.h" | 10 #include "base/callback.h" |
(...skipping 28 matching lines...) Expand all Loading... |
39 | 39 |
40 } // namespace | 40 } // namespace |
41 | 41 |
42 class QuotaDatabaseTest : public testing::Test { | 42 class QuotaDatabaseTest : public testing::Test { |
43 protected: | 43 protected: |
44 typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry; | 44 typedef QuotaDatabase::QuotaTableEntry QuotaTableEntry; |
45 typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback; | 45 typedef QuotaDatabase::QuotaTableCallback QuotaTableCallback; |
46 typedef QuotaDatabase::OriginInfoTableCallback | 46 typedef QuotaDatabase::OriginInfoTableCallback |
47 OriginInfoTableCallback; | 47 OriginInfoTableCallback; |
48 | 48 |
49 void LazyOpen(const FilePath& kDbFile) { | 49 void LazyOpen(const base::FilePath& kDbFile) { |
50 QuotaDatabase db(kDbFile); | 50 QuotaDatabase db(kDbFile); |
51 EXPECT_FALSE(db.LazyOpen(false)); | 51 EXPECT_FALSE(db.LazyOpen(false)); |
52 ASSERT_TRUE(db.LazyOpen(true)); | 52 ASSERT_TRUE(db.LazyOpen(true)); |
53 EXPECT_TRUE(db.db_.get()); | 53 EXPECT_TRUE(db.db_.get()); |
54 EXPECT_TRUE(kDbFile.empty() || file_util::PathExists(kDbFile)); | 54 EXPECT_TRUE(kDbFile.empty() || file_util::PathExists(kDbFile)); |
55 } | 55 } |
56 | 56 |
57 void UpgradeSchemaV2toV3(const FilePath& kDbFile) { | 57 void UpgradeSchemaV2toV3(const base::FilePath& kDbFile) { |
58 const QuotaTableEntry entries[] = { | 58 const QuotaTableEntry entries[] = { |
59 QuotaTableEntry("a", kStorageTypeTemporary, 1), | 59 QuotaTableEntry("a", kStorageTypeTemporary, 1), |
60 QuotaTableEntry("b", kStorageTypeTemporary, 2), | 60 QuotaTableEntry("b", kStorageTypeTemporary, 2), |
61 QuotaTableEntry("c", kStorageTypePersistent, 3), | 61 QuotaTableEntry("c", kStorageTypePersistent, 3), |
62 }; | 62 }; |
63 | 63 |
64 CreateV2Database(kDbFile, entries, ARRAYSIZE_UNSAFE(entries)); | 64 CreateV2Database(kDbFile, entries, ARRAYSIZE_UNSAFE(entries)); |
65 | 65 |
66 QuotaDatabase db(kDbFile); | 66 QuotaDatabase db(kDbFile); |
67 EXPECT_TRUE(db.LazyOpen(true)); | 67 EXPECT_TRUE(db.LazyOpen(true)); |
68 EXPECT_TRUE(db.db_.get()); | 68 EXPECT_TRUE(db.db_.get()); |
69 | 69 |
70 typedef EntryVerifier<QuotaTableEntry> Verifier; | 70 typedef EntryVerifier<QuotaTableEntry> Verifier; |
71 Verifier verifier(entries, entries + ARRAYSIZE_UNSAFE(entries)); | 71 Verifier verifier(entries, entries + ARRAYSIZE_UNSAFE(entries)); |
72 EXPECT_TRUE(db.DumpQuotaTable( | 72 EXPECT_TRUE(db.DumpQuotaTable( |
73 new QuotaTableCallback( | 73 new QuotaTableCallback( |
74 base::Bind(&Verifier::Run, | 74 base::Bind(&Verifier::Run, |
75 base::Unretained(&verifier))))); | 75 base::Unretained(&verifier))))); |
76 EXPECT_TRUE(verifier.table.empty()); | 76 EXPECT_TRUE(verifier.table.empty()); |
77 } | 77 } |
78 | 78 |
79 void HostQuota(const FilePath& kDbFile) { | 79 void HostQuota(const base::FilePath& kDbFile) { |
80 QuotaDatabase db(kDbFile); | 80 QuotaDatabase db(kDbFile); |
81 ASSERT_TRUE(db.LazyOpen(true)); | 81 ASSERT_TRUE(db.LazyOpen(true)); |
82 | 82 |
83 const char* kHost = "foo.com"; | 83 const char* kHost = "foo.com"; |
84 const int kQuota1 = 13579; | 84 const int kQuota1 = 13579; |
85 const int kQuota2 = kQuota1 + 1024; | 85 const int kQuota2 = kQuota1 + 1024; |
86 | 86 |
87 int64 quota = -1; | 87 int64 quota = -1; |
88 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); | 88 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); |
89 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, "a)); | 89 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, "a)); |
90 | 90 |
91 // Insert quota for temporary. | 91 // Insert quota for temporary. |
92 EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota1)); | 92 EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota1)); |
93 EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); | 93 EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); |
94 EXPECT_EQ(kQuota1, quota); | 94 EXPECT_EQ(kQuota1, quota); |
95 | 95 |
96 // Update quota for temporary. | 96 // Update quota for temporary. |
97 EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota2)); | 97 EXPECT_TRUE(db.SetHostQuota(kHost, kStorageTypeTemporary, kQuota2)); |
98 EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); | 98 EXPECT_TRUE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); |
99 EXPECT_EQ(kQuota2, quota); | 99 EXPECT_EQ(kQuota2, quota); |
100 | 100 |
101 // Quota for persistent must not be updated. | 101 // Quota for persistent must not be updated. |
102 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, "a)); | 102 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypePersistent, "a)); |
103 | 103 |
104 // Delete temporary storage quota. | 104 // Delete temporary storage quota. |
105 EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary)); | 105 EXPECT_TRUE(db.DeleteHostQuota(kHost, kStorageTypeTemporary)); |
106 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); | 106 EXPECT_FALSE(db.GetHostQuota(kHost, kStorageTypeTemporary, "a)); |
107 } | 107 } |
108 | 108 |
109 void GlobalQuota(const FilePath& kDbFile) { | 109 void GlobalQuota(const base::FilePath& kDbFile) { |
110 QuotaDatabase db(kDbFile); | 110 QuotaDatabase db(kDbFile); |
111 ASSERT_TRUE(db.LazyOpen(true)); | 111 ASSERT_TRUE(db.LazyOpen(true)); |
112 | 112 |
113 const char* kTempQuotaKey = QuotaDatabase::kTemporaryQuotaOverrideKey; | 113 const char* kTempQuotaKey = QuotaDatabase::kTemporaryQuotaOverrideKey; |
114 const char* kAvailSpaceKey = QuotaDatabase::kDesiredAvailableSpaceKey; | 114 const char* kAvailSpaceKey = QuotaDatabase::kDesiredAvailableSpaceKey; |
115 | 115 |
116 int64 value = 0; | 116 int64 value = 0; |
117 const int64 kValue1 = 456; | 117 const int64 kValue1 = 456; |
118 const int64 kValue2 = 123000; | 118 const int64 kValue2 = 123000; |
119 EXPECT_FALSE(db.GetQuotaConfigValue(kTempQuotaKey, &value)); | 119 EXPECT_FALSE(db.GetQuotaConfigValue(kTempQuotaKey, &value)); |
120 EXPECT_FALSE(db.GetQuotaConfigValue(kAvailSpaceKey, &value)); | 120 EXPECT_FALSE(db.GetQuotaConfigValue(kAvailSpaceKey, &value)); |
121 | 121 |
122 EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue1)); | 122 EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue1)); |
123 EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value)); | 123 EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value)); |
124 EXPECT_EQ(kValue1, value); | 124 EXPECT_EQ(kValue1, value); |
125 | 125 |
126 EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue2)); | 126 EXPECT_TRUE(db.SetQuotaConfigValue(kTempQuotaKey, kValue2)); |
127 EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value)); | 127 EXPECT_TRUE(db.GetQuotaConfigValue(kTempQuotaKey, &value)); |
128 EXPECT_EQ(kValue2, value); | 128 EXPECT_EQ(kValue2, value); |
129 | 129 |
130 EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue1)); | 130 EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue1)); |
131 EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value)); | 131 EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value)); |
132 EXPECT_EQ(kValue1, value); | 132 EXPECT_EQ(kValue1, value); |
133 | 133 |
134 EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue2)); | 134 EXPECT_TRUE(db.SetQuotaConfigValue(kAvailSpaceKey, kValue2)); |
135 EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value)); | 135 EXPECT_TRUE(db.GetQuotaConfigValue(kAvailSpaceKey, &value)); |
136 EXPECT_EQ(kValue2, value); | 136 EXPECT_EQ(kValue2, value); |
137 } | 137 } |
138 | 138 |
139 void OriginLastAccessTimeLRU(const FilePath& kDbFile) { | 139 void OriginLastAccessTimeLRU(const base::FilePath& kDbFile) { |
140 QuotaDatabase db(kDbFile); | 140 QuotaDatabase db(kDbFile); |
141 ASSERT_TRUE(db.LazyOpen(true)); | 141 ASSERT_TRUE(db.LazyOpen(true)); |
142 | 142 |
143 std::set<GURL> exceptions; | 143 std::set<GURL> exceptions; |
144 GURL origin; | 144 GURL origin; |
145 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, | 145 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, |
146 NULL, &origin)); | 146 NULL, &origin)); |
147 EXPECT_TRUE(origin.is_empty()); | 147 EXPECT_TRUE(origin.is_empty()); |
148 | 148 |
149 const GURL kOrigin1("http://a/"); | 149 const GURL kOrigin1("http://a/"); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
204 NULL, &origin)); | 204 NULL, &origin)); |
205 EXPECT_EQ(kOrigin2.spec(), origin.spec()); | 205 EXPECT_EQ(kOrigin2.spec(), origin.spec()); |
206 | 206 |
207 exceptions.insert(kOrigin1); | 207 exceptions.insert(kOrigin1); |
208 exceptions.insert(kOrigin2); | 208 exceptions.insert(kOrigin2); |
209 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, | 209 EXPECT_TRUE(db.GetLRUOrigin(kStorageTypeTemporary, exceptions, |
210 NULL, &origin)); | 210 NULL, &origin)); |
211 EXPECT_TRUE(origin.is_empty()); | 211 EXPECT_TRUE(origin.is_empty()); |
212 } | 212 } |
213 | 213 |
214 void OriginLastModifiedSince(const FilePath& kDbFile) { | 214 void OriginLastModifiedSince(const base::FilePath& kDbFile) { |
215 QuotaDatabase db(kDbFile); | 215 QuotaDatabase db(kDbFile); |
216 ASSERT_TRUE(db.LazyOpen(true)); | 216 ASSERT_TRUE(db.LazyOpen(true)); |
217 | 217 |
218 std::set<GURL> origins; | 218 std::set<GURL> origins; |
219 EXPECT_TRUE(db.GetOriginsModifiedSince( | 219 EXPECT_TRUE(db.GetOriginsModifiedSince( |
220 kStorageTypeTemporary, &origins, base::Time())); | 220 kStorageTypeTemporary, &origins, base::Time())); |
221 EXPECT_TRUE(origins.empty()); | 221 EXPECT_TRUE(origins.empty()); |
222 | 222 |
223 const GURL kOrigin1("http://a/"); | 223 const GURL kOrigin1("http://a/"); |
224 const GURL kOrigin2("http://b/"); | 224 const GURL kOrigin2("http://b/"); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
281 EXPECT_EQ(0U, origins.count(kOrigin3)); | 281 EXPECT_EQ(0U, origins.count(kOrigin3)); |
282 | 282 |
283 EXPECT_TRUE(db.GetOriginsModifiedSince( | 283 EXPECT_TRUE(db.GetOriginsModifiedSince( |
284 kStorageTypePersistent, &origins, base::Time::FromInternalValue(35))); | 284 kStorageTypePersistent, &origins, base::Time::FromInternalValue(35))); |
285 EXPECT_EQ(1U, origins.size()); | 285 EXPECT_EQ(1U, origins.size()); |
286 EXPECT_EQ(0U, origins.count(kOrigin1)); | 286 EXPECT_EQ(0U, origins.count(kOrigin1)); |
287 EXPECT_EQ(1U, origins.count(kOrigin2)); | 287 EXPECT_EQ(1U, origins.count(kOrigin2)); |
288 EXPECT_EQ(0U, origins.count(kOrigin3)); | 288 EXPECT_EQ(0U, origins.count(kOrigin3)); |
289 } | 289 } |
290 | 290 |
291 void RegisterInitialOriginInfo(const FilePath& kDbFile) { | 291 void RegisterInitialOriginInfo(const base::FilePath& kDbFile) { |
292 QuotaDatabase db(kDbFile); | 292 QuotaDatabase db(kDbFile); |
293 | 293 |
294 const GURL kOrigins[] = { | 294 const GURL kOrigins[] = { |
295 GURL("http://a/"), | 295 GURL("http://a/"), |
296 GURL("http://b/"), | 296 GURL("http://b/"), |
297 GURL("http://c/") }; | 297 GURL("http://c/") }; |
298 std::set<GURL> origins(kOrigins, kOrigins + ARRAYSIZE_UNSAFE(kOrigins)); | 298 std::set<GURL> origins(kOrigins, kOrigins + ARRAYSIZE_UNSAFE(kOrigins)); |
299 | 299 |
300 EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary)); | 300 EXPECT_TRUE(db.RegisterInitialOriginInfo(origins, kStorageTypeTemporary)); |
301 | 301 |
(...skipping 28 matching lines...) Expand all Loading... |
330 template <typename Iterator> | 330 template <typename Iterator> |
331 EntryVerifier(Iterator itr, Iterator end) | 331 EntryVerifier(Iterator itr, Iterator end) |
332 : table(itr, end) {} | 332 : table(itr, end) {} |
333 | 333 |
334 bool Run(const EntryType& entry) { | 334 bool Run(const EntryType& entry) { |
335 EXPECT_EQ(1u, table.erase(entry)); | 335 EXPECT_EQ(1u, table.erase(entry)); |
336 return true; | 336 return true; |
337 } | 337 } |
338 }; | 338 }; |
339 | 339 |
340 void DumpQuotaTable(const FilePath& kDbFile) { | 340 void DumpQuotaTable(const base::FilePath& kDbFile) { |
341 QuotaTableEntry kTableEntries[] = { | 341 QuotaTableEntry kTableEntries[] = { |
342 QuotaTableEntry("http://go/", kStorageTypeTemporary, 1), | 342 QuotaTableEntry("http://go/", kStorageTypeTemporary, 1), |
343 QuotaTableEntry("http://oo/", kStorageTypeTemporary, 2), | 343 QuotaTableEntry("http://oo/", kStorageTypeTemporary, 2), |
344 QuotaTableEntry("http://gle/", kStorageTypePersistent, 3) | 344 QuotaTableEntry("http://gle/", kStorageTypePersistent, 3) |
345 }; | 345 }; |
346 QuotaTableEntry* begin = kTableEntries; | 346 QuotaTableEntry* begin = kTableEntries; |
347 QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries); | 347 QuotaTableEntry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries); |
348 | 348 |
349 QuotaDatabase db(kDbFile); | 349 QuotaDatabase db(kDbFile); |
350 EXPECT_TRUE(db.LazyOpen(true)); | 350 EXPECT_TRUE(db.LazyOpen(true)); |
351 AssignQuotaTable(db.db_.get(), begin, end); | 351 AssignQuotaTable(db.db_.get(), begin, end); |
352 db.Commit(); | 352 db.Commit(); |
353 | 353 |
354 typedef EntryVerifier<QuotaTableEntry> Verifier; | 354 typedef EntryVerifier<QuotaTableEntry> Verifier; |
355 Verifier verifier(begin, end); | 355 Verifier verifier(begin, end); |
356 EXPECT_TRUE(db.DumpQuotaTable( | 356 EXPECT_TRUE(db.DumpQuotaTable( |
357 new QuotaTableCallback( | 357 new QuotaTableCallback( |
358 base::Bind(&Verifier::Run, | 358 base::Bind(&Verifier::Run, |
359 base::Unretained(&verifier))))); | 359 base::Unretained(&verifier))))); |
360 EXPECT_TRUE(verifier.table.empty()); | 360 EXPECT_TRUE(verifier.table.empty()); |
361 } | 361 } |
362 | 362 |
363 void DumpOriginInfoTable(const FilePath& kDbFile) { | 363 void DumpOriginInfoTable(const base::FilePath& kDbFile) { |
364 base::Time now(base::Time::Now()); | 364 base::Time now(base::Time::Now()); |
365 typedef QuotaDatabase::OriginInfoTableEntry Entry; | 365 typedef QuotaDatabase::OriginInfoTableEntry Entry; |
366 Entry kTableEntries[] = { | 366 Entry kTableEntries[] = { |
367 Entry(GURL("http://go/"), kStorageTypeTemporary, 2147483647, now, now), | 367 Entry(GURL("http://go/"), kStorageTypeTemporary, 2147483647, now, now), |
368 Entry(GURL("http://oo/"), kStorageTypeTemporary, 0, now, now), | 368 Entry(GURL("http://oo/"), kStorageTypeTemporary, 0, now, now), |
369 Entry(GURL("http://gle/"), kStorageTypeTemporary, 1, now, now), | 369 Entry(GURL("http://gle/"), kStorageTypeTemporary, 1, now, now), |
370 }; | 370 }; |
371 Entry* begin = kTableEntries; | 371 Entry* begin = kTableEntries; |
372 Entry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries); | 372 Entry* end = kTableEntries + ARRAYSIZE_UNSAFE(kTableEntries); |
373 | 373 |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
419 | 419 |
420 statement.BindString(0, itr->origin.spec()); | 420 statement.BindString(0, itr->origin.spec()); |
421 statement.BindInt(1, static_cast<int>(itr->type)); | 421 statement.BindInt(1, static_cast<int>(itr->type)); |
422 statement.BindInt(2, itr->used_count); | 422 statement.BindInt(2, itr->used_count); |
423 statement.BindInt64(3, itr->last_access_time.ToInternalValue()); | 423 statement.BindInt64(3, itr->last_access_time.ToInternalValue()); |
424 statement.BindInt64(4, itr->last_modified_time.ToInternalValue()); | 424 statement.BindInt64(4, itr->last_modified_time.ToInternalValue()); |
425 EXPECT_TRUE(statement.Run()); | 425 EXPECT_TRUE(statement.Run()); |
426 } | 426 } |
427 } | 427 } |
428 | 428 |
429 bool OpenDatabase(sql::Connection* db, const FilePath& kDbFile) { | 429 bool OpenDatabase(sql::Connection* db, const base::FilePath& kDbFile) { |
430 if (kDbFile.empty()) { | 430 if (kDbFile.empty()) { |
431 return db->OpenInMemory(); | 431 return db->OpenInMemory(); |
432 } | 432 } |
433 if (!file_util::CreateDirectory(kDbFile.DirName())) | 433 if (!file_util::CreateDirectory(kDbFile.DirName())) |
434 return false; | 434 return false; |
435 if (!db->Open(kDbFile)) | 435 if (!db->Open(kDbFile)) |
436 return false; | 436 return false; |
437 db->Preload(); | 437 db->Preload(); |
438 return true; | 438 return true; |
439 } | 439 } |
440 | 440 |
441 // Create V2 database and populate some data. | 441 // Create V2 database and populate some data. |
442 void CreateV2Database( | 442 void CreateV2Database( |
443 const FilePath& kDbFile, | 443 const base::FilePath& kDbFile, |
444 const QuotaTableEntry* entries, | 444 const QuotaTableEntry* entries, |
445 size_t entries_size) { | 445 size_t entries_size) { |
446 scoped_ptr<sql::Connection> db(new sql::Connection); | 446 scoped_ptr<sql::Connection> db(new sql::Connection); |
447 scoped_ptr<sql::MetaTable> meta_table(new sql::MetaTable); | 447 scoped_ptr<sql::MetaTable> meta_table(new sql::MetaTable); |
448 | 448 |
449 // V2 schema definitions. | 449 // V2 schema definitions. |
450 static const int kCurrentVersion = 2; | 450 static const int kCurrentVersion = 2; |
451 static const int kCompatibleVersion = 2; | 451 static const int kCompatibleVersion = 2; |
452 static const char kHostQuotaTable[] = "HostQuotaTable"; | 452 static const char kHostQuotaTable[] = "HostQuotaTable"; |
453 static const char kOriginLastAccessTable[] = "OriginLastAccessTable"; | 453 static const char kOriginLastAccessTable[] = "OriginLastAccessTable"; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
488 AssignQuotaTable(db.get(), entries, entries + entries_size); | 488 AssignQuotaTable(db.get(), entries, entries + entries_size); |
489 db->CommitTransaction(); | 489 db->CommitTransaction(); |
490 } | 490 } |
491 | 491 |
492 MessageLoop message_loop_; | 492 MessageLoop message_loop_; |
493 }; | 493 }; |
494 | 494 |
495 TEST_F(QuotaDatabaseTest, LazyOpen) { | 495 TEST_F(QuotaDatabaseTest, LazyOpen) { |
496 base::ScopedTempDir data_dir; | 496 base::ScopedTempDir data_dir; |
497 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 497 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
498 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 498 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
499 LazyOpen(kDbFile); | 499 LazyOpen(kDbFile); |
500 LazyOpen(FilePath()); | 500 LazyOpen(base::FilePath()); |
501 } | 501 } |
502 | 502 |
503 TEST_F(QuotaDatabaseTest, UpgradeSchema) { | 503 TEST_F(QuotaDatabaseTest, UpgradeSchema) { |
504 base::ScopedTempDir data_dir; | 504 base::ScopedTempDir data_dir; |
505 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 505 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
506 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 506 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
507 UpgradeSchemaV2toV3(kDbFile); | 507 UpgradeSchemaV2toV3(kDbFile); |
508 } | 508 } |
509 | 509 |
510 TEST_F(QuotaDatabaseTest, HostQuota) { | 510 TEST_F(QuotaDatabaseTest, HostQuota) { |
511 base::ScopedTempDir data_dir; | 511 base::ScopedTempDir data_dir; |
512 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 512 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
513 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 513 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
514 HostQuota(kDbFile); | 514 HostQuota(kDbFile); |
515 HostQuota(FilePath()); | 515 HostQuota(base::FilePath()); |
516 } | 516 } |
517 | 517 |
518 TEST_F(QuotaDatabaseTest, GlobalQuota) { | 518 TEST_F(QuotaDatabaseTest, GlobalQuota) { |
519 base::ScopedTempDir data_dir; | 519 base::ScopedTempDir data_dir; |
520 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 520 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
521 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 521 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
522 GlobalQuota(kDbFile); | 522 GlobalQuota(kDbFile); |
523 GlobalQuota(FilePath()); | 523 GlobalQuota(base::FilePath()); |
524 } | 524 } |
525 | 525 |
526 TEST_F(QuotaDatabaseTest, OriginLastAccessTimeLRU) { | 526 TEST_F(QuotaDatabaseTest, OriginLastAccessTimeLRU) { |
527 base::ScopedTempDir data_dir; | 527 base::ScopedTempDir data_dir; |
528 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 528 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
529 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 529 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
530 OriginLastAccessTimeLRU(kDbFile); | 530 OriginLastAccessTimeLRU(kDbFile); |
531 OriginLastAccessTimeLRU(FilePath()); | 531 OriginLastAccessTimeLRU(base::FilePath()); |
532 } | 532 } |
533 | 533 |
534 TEST_F(QuotaDatabaseTest, OriginLastModifiedSince) { | 534 TEST_F(QuotaDatabaseTest, OriginLastModifiedSince) { |
535 base::ScopedTempDir data_dir; | 535 base::ScopedTempDir data_dir; |
536 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 536 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
537 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 537 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
538 OriginLastModifiedSince(kDbFile); | 538 OriginLastModifiedSince(kDbFile); |
539 OriginLastModifiedSince(FilePath()); | 539 OriginLastModifiedSince(base::FilePath()); |
540 } | 540 } |
541 | 541 |
542 TEST_F(QuotaDatabaseTest, BootstrapFlag) { | 542 TEST_F(QuotaDatabaseTest, BootstrapFlag) { |
543 base::ScopedTempDir data_dir; | 543 base::ScopedTempDir data_dir; |
544 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 544 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
545 | 545 |
546 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 546 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
547 QuotaDatabase db(kDbFile); | 547 QuotaDatabase db(kDbFile); |
548 | 548 |
549 EXPECT_FALSE(db.IsOriginDatabaseBootstrapped()); | 549 EXPECT_FALSE(db.IsOriginDatabaseBootstrapped()); |
550 EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(true)); | 550 EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(true)); |
551 EXPECT_TRUE(db.IsOriginDatabaseBootstrapped()); | 551 EXPECT_TRUE(db.IsOriginDatabaseBootstrapped()); |
552 EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(false)); | 552 EXPECT_TRUE(db.SetOriginDatabaseBootstrapped(false)); |
553 EXPECT_FALSE(db.IsOriginDatabaseBootstrapped()); | 553 EXPECT_FALSE(db.IsOriginDatabaseBootstrapped()); |
554 } | 554 } |
555 | 555 |
556 TEST_F(QuotaDatabaseTest, RegisterInitialOriginInfo) { | 556 TEST_F(QuotaDatabaseTest, RegisterInitialOriginInfo) { |
557 base::ScopedTempDir data_dir; | 557 base::ScopedTempDir data_dir; |
558 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 558 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
559 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 559 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
560 RegisterInitialOriginInfo(kDbFile); | 560 RegisterInitialOriginInfo(kDbFile); |
561 RegisterInitialOriginInfo(FilePath()); | 561 RegisterInitialOriginInfo(base::FilePath()); |
562 } | 562 } |
563 | 563 |
564 TEST_F(QuotaDatabaseTest, DumpQuotaTable) { | 564 TEST_F(QuotaDatabaseTest, DumpQuotaTable) { |
565 base::ScopedTempDir data_dir; | 565 base::ScopedTempDir data_dir; |
566 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 566 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
567 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 567 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
568 DumpQuotaTable(kDbFile); | 568 DumpQuotaTable(kDbFile); |
569 DumpQuotaTable(FilePath()); | 569 DumpQuotaTable(base::FilePath()); |
570 } | 570 } |
571 | 571 |
572 TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) { | 572 TEST_F(QuotaDatabaseTest, DumpOriginInfoTable) { |
573 base::ScopedTempDir data_dir; | 573 base::ScopedTempDir data_dir; |
574 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); | 574 ASSERT_TRUE(data_dir.CreateUniqueTempDir()); |
575 const FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db"); | 575 const base::FilePath kDbFile = data_dir.path().AppendASCII("quota_manager.db")
; |
576 DumpOriginInfoTable(kDbFile); | 576 DumpOriginInfoTable(kDbFile); |
577 DumpOriginInfoTable(FilePath()); | 577 DumpOriginInfoTable(base::FilePath()); |
578 } | 578 } |
579 } // namespace quota | 579 } // namespace quota |
OLD | NEW |