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
23using storage::kStorageTypePersistent;
24using storage::kStorageTypeTemporary;
25using storage::QuotaDatabase;
26
27namespace content {
28namespace {
29
30const base::Time kZeroTime;
31
32const char kDBFileName[] = "quota_manager.db";
33
34}  // namespace
35
36class 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
483TEST_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
491TEST_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
498TEST_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
506TEST_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
514TEST_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
522TEST_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
530TEST_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
544TEST_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
552TEST_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
560TEST_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