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
3 // found in the LICENSE file.
5 #include "base/file_util.h"
6 #include "base/files/file.h"
7 #include "base/files/file_path.h"
8 #include "base/files/scoped_temp_dir.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/message_loop/message_loop.h"
11 #include "base/message_loop/message_loop_proxy.h"
12 #include "base/strings/utf_string_conversions.h"
13 #include "base/time/time.h"
14 #include "net/base/net_errors.h"
15 #include "net/base/test_completion_callback.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17 #include "third_party/sqlite/sqlite3.h"
18 #include "webkit/browser/database/database_tracker.h"
19 #include "webkit/browser/quota/mock_special_storage_policy.h"
20 #include "webkit/browser/quota/quota_manager_proxy.h"
21 #include "webkit/common/database/database_identifier.h"
23 using base::ASCIIToUTF16;
27 const char kOrigin1Url[] = "http://origin1";
28 const char kOrigin2Url[] = "http://protected_origin2";
30 class TestObserver : public webkit_database::DatabaseTracker::Observer {
33 : new_notification_received_(false),
34 observe_size_changes_(true),
35 observe_scheduled_deletions_(true) {
37 TestObserver(bool observe_size_changes, bool observe_scheduled_deletions)
38 : new_notification_received_(false),
39 observe_size_changes_(observe_size_changes),
40 observe_scheduled_deletions_(observe_scheduled_deletions) {
43 virtual ~TestObserver() {}
44 virtual void OnDatabaseSizeChanged(const std::string& origin_identifier,
45 const base::string16& database_name,
46 int64 database_size) OVERRIDE {
47 if (!observe_size_changes_)
49 new_notification_received_ = true;
50 origin_identifier_ = origin_identifier;
51 database_name_ = database_name;
52 database_size_ = database_size;
54 virtual void OnDatabaseScheduledForDeletion(
55 const std::string& origin_identifier,
56 const base::string16& database_name) OVERRIDE {
57 if (!observe_scheduled_deletions_)
59 new_notification_received_ = true;
60 origin_identifier_ = origin_identifier;
61 database_name_ = database_name;
63 bool DidReceiveNewNotification() {
64 bool temp_new_notification_received = new_notification_received_;
65 new_notification_received_ = false;
66 return temp_new_notification_received;
68 std::string GetNotificationOriginIdentifier() {
69 return origin_identifier_;
71 base::string16 GetNotificationDatabaseName() { return database_name_; }
72 int64 GetNotificationDatabaseSize() { return database_size_; }
75 bool new_notification_received_;
76 bool observe_size_changes_;
77 bool observe_scheduled_deletions_;
78 std::string origin_identifier_;
79 base::string16 database_name_;
83 void CheckNotificationReceived(TestObserver* observer,
84 const std::string& expected_origin_identifier,
85 const base::string16& expected_database_name,
86 int64 expected_database_size) {
87 EXPECT_TRUE(observer->DidReceiveNewNotification());
88 EXPECT_EQ(expected_origin_identifier,
89 observer->GetNotificationOriginIdentifier());
90 EXPECT_EQ(expected_database_name,
91 observer->GetNotificationDatabaseName());
92 EXPECT_EQ(expected_database_size,
93 observer->GetNotificationDatabaseSize());
96 class TestQuotaManagerProxy : public quota::QuotaManagerProxy {
98 TestQuotaManagerProxy()
99 : QuotaManagerProxy(NULL, NULL),
100 registered_client_(NULL) {
103 virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {
104 EXPECT_FALSE(registered_client_);
105 registered_client_ = client;
108 virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
110 quota::StorageType type) OVERRIDE {
111 EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
112 EXPECT_EQ(quota::kStorageTypeTemporary, type);
113 accesses_[origin] += 1;
116 virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
118 quota::StorageType type,
119 int64 delta) OVERRIDE {
120 EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
121 EXPECT_EQ(quota::kStorageTypeTemporary, type);
122 modifications_[origin].first += 1;
123 modifications_[origin].second += delta;
126 // Not needed for our tests.
127 virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
128 virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
129 virtual void SetUsageCacheEnabled(quota::QuotaClient::ID client_id,
131 quota::StorageType type,
132 bool enabled) OVERRIDE {}
133 virtual void GetUsageAndQuota(
134 base::SequencedTaskRunner* original_task_runner,
136 quota::StorageType type,
137 const GetUsageAndQuotaCallback& callback) OVERRIDE {}
139 void SimulateQuotaManagerDestroyed() {
140 if (registered_client_) {
141 registered_client_->OnQuotaManagerDestroyed();
142 registered_client_ = NULL;
146 bool WasAccessNotified(const GURL& origin) {
147 return accesses_[origin] != 0;
150 bool WasModificationNotified(const GURL& origin, int64 amount) {
151 return modifications_[origin].first != 0 &&
152 modifications_[origin].second == amount;
157 modifications_.clear();
160 quota::QuotaClient* registered_client_;
162 // Map from origin to count of access notifications.
163 std::map<GURL, int> accesses_;
165 // Map from origin to <count, sum of deltas>
166 std::map<GURL, std::pair<int, int64> > modifications_;
169 virtual ~TestQuotaManagerProxy() {
170 EXPECT_FALSE(registered_client_);
175 bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
176 base::File file(file_path,
177 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
180 return file.SetLength(length);
185 namespace webkit_database {
187 // We declare a helper class, and make it a friend of DatabaseTracker using
188 // the FRIEND_TEST() macro, and we implement all tests we want to run as
189 // static methods of this class. Then we make our TEST() targets call these
190 // static functions. This allows us to run each test in normal mode and
191 // incognito mode without writing the same code twice.
192 class DatabaseTracker_TestHelper_Test {
194 static void TestDeleteOpenDatabase(bool incognito_mode) {
195 // Initialize the tracker database.
196 base::ScopedTempDir temp_dir;
197 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
198 scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
199 new quota::MockSpecialStoragePolicy;
200 special_storage_policy->AddProtected(GURL(kOrigin2Url));
201 scoped_refptr<DatabaseTracker> tracker(
202 new DatabaseTracker(temp_dir.path(),
204 special_storage_policy.get(),
208 // Create and open three databases.
209 int64 database_size = 0;
210 const std::string kOrigin1 =
211 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
212 const std::string kOrigin2 =
213 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
214 const base::string16 kDB1 = ASCIIToUTF16("db1");
215 const base::string16 kDB2 = ASCIIToUTF16("db2");
216 const base::string16 kDB3 = ASCIIToUTF16("db3");
217 const base::string16 kDescription = ASCIIToUTF16("database_description");
219 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
221 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
223 tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0,
226 EXPECT_TRUE(base::CreateDirectory(
227 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
228 tracker->GetOriginDirectory(kOrigin1)))));
229 EXPECT_TRUE(base::CreateDirectory(
230 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
231 tracker->GetOriginDirectory(kOrigin2)))));
232 EXPECT_EQ(1, file_util::WriteFile(
233 tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
234 EXPECT_EQ(2, file_util::WriteFile(
235 tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
236 EXPECT_EQ(3, file_util::WriteFile(
237 tracker->GetFullDBFilePath(kOrigin2, kDB3), "aaa", 3));
238 tracker->DatabaseModified(kOrigin1, kDB1);
239 tracker->DatabaseModified(kOrigin2, kDB2);
240 tracker->DatabaseModified(kOrigin2, kDB3);
242 // Delete db1. Should also delete origin1.
243 TestObserver observer;
244 tracker->AddObserver(&observer);
245 net::TestCompletionCallback callback;
246 int result = tracker->DeleteDatabase(kOrigin1, kDB1, callback.callback());
247 EXPECT_EQ(net::ERR_IO_PENDING, result);
248 ASSERT_FALSE(callback.have_result());
249 EXPECT_TRUE(observer.DidReceiveNewNotification());
250 EXPECT_EQ(kOrigin1, observer.GetNotificationOriginIdentifier());
251 EXPECT_EQ(kDB1, observer.GetNotificationDatabaseName());
252 tracker->DatabaseClosed(kOrigin1, kDB1);
253 result = callback.GetResult(result);
254 EXPECT_EQ(net::OK, result);
255 EXPECT_FALSE(base::PathExists(
256 tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
259 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
261 EXPECT_TRUE(base::CreateDirectory(
262 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
263 tracker->GetOriginDirectory(kOrigin1)))));
264 EXPECT_EQ(1, file_util::WriteFile(
265 tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
266 tracker->DatabaseModified(kOrigin1, kDB1);
268 // Setup file modification times. db1 and db2 are modified now, db3 three
270 base::Time now = base::Time::Now();
271 EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin1, kDB1),
273 EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB2),
275 base::Time three_days_ago = now - base::TimeDelta::FromDays(3);
276 EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB3),
277 three_days_ago, three_days_ago));
279 // Delete databases modified since yesterday. db2 is whitelisted.
280 base::Time yesterday = base::Time::Now();
281 yesterday -= base::TimeDelta::FromDays(1);
282 result = tracker->DeleteDataModifiedSince(
283 yesterday, callback.callback());
284 EXPECT_EQ(net::ERR_IO_PENDING, result);
285 ASSERT_FALSE(callback.have_result());
286 EXPECT_TRUE(observer.DidReceiveNewNotification());
287 tracker->DatabaseClosed(kOrigin1, kDB1);
288 tracker->DatabaseClosed(kOrigin2, kDB2);
289 result = callback.GetResult(result);
290 EXPECT_EQ(net::OK, result);
291 EXPECT_FALSE(base::PathExists(
292 tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
294 base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
296 base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
298 tracker->DatabaseClosed(kOrigin2, kDB3);
299 tracker->RemoveObserver(&observer);
302 static void TestDatabaseTracker(bool incognito_mode) {
303 // Initialize the tracker database.
304 base::ScopedTempDir temp_dir;
305 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
306 scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
307 new quota::MockSpecialStoragePolicy;
308 special_storage_policy->AddProtected(GURL(kOrigin2Url));
309 scoped_refptr<DatabaseTracker> tracker(
310 new DatabaseTracker(temp_dir.path(),
312 special_storage_policy.get(),
316 // Add two observers.
317 TestObserver observer1;
318 TestObserver observer2;
319 tracker->AddObserver(&observer1);
320 tracker->AddObserver(&observer2);
322 // Open three new databases.
323 int64 database_size = 0;
324 const std::string kOrigin1 =
325 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
326 const std::string kOrigin2 =
327 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
328 const base::string16 kDB1 = ASCIIToUTF16("db1");
329 const base::string16 kDB2 = ASCIIToUTF16("db2");
330 const base::string16 kDB3 = ASCIIToUTF16("db3");
331 const base::string16 kDescription = ASCIIToUTF16("database_description");
333 // Get the info for kOrigin1 and kOrigin2
334 DatabaseTracker::CachedOriginInfo* origin1_info =
335 tracker->GetCachedOriginInfo(kOrigin1);
336 DatabaseTracker::CachedOriginInfo* origin2_info =
337 tracker->GetCachedOriginInfo(kOrigin1);
338 EXPECT_TRUE(origin1_info);
339 EXPECT_TRUE(origin2_info);
342 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
344 EXPECT_EQ(0, database_size);
345 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
347 EXPECT_EQ(0, database_size);
348 tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
350 EXPECT_EQ(0, database_size);
352 // Write some data to each file and check that the listeners are
353 // called with the appropriate values.
354 EXPECT_TRUE(base::CreateDirectory(
355 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
356 tracker->GetOriginDirectory(kOrigin1)))));
357 EXPECT_TRUE(base::CreateDirectory(
358 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
359 tracker->GetOriginDirectory(kOrigin2)))));
360 EXPECT_EQ(1, file_util::WriteFile(
361 tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
362 EXPECT_EQ(2, file_util::WriteFile(
363 tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
364 EXPECT_EQ(4, file_util::WriteFile(
365 tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa", 4));
366 tracker->DatabaseModified(kOrigin1, kDB1);
367 CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1);
368 CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1);
369 tracker->DatabaseModified(kOrigin2, kDB2);
370 CheckNotificationReceived(&observer1, kOrigin2, kDB2, 2);
371 CheckNotificationReceived(&observer2, kOrigin2, kDB2, 2);
372 tracker->DatabaseModified(kOrigin1, kDB3);
373 CheckNotificationReceived(&observer1, kOrigin1, kDB3, 4);
374 CheckNotificationReceived(&observer2, kOrigin1, kDB3, 4);
376 // Close all databases
377 tracker->DatabaseClosed(kOrigin1, kDB1);
378 tracker->DatabaseClosed(kOrigin2, kDB2);
379 tracker->DatabaseClosed(kOrigin1, kDB3);
381 // Open an existing database and check the reported size
382 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
384 EXPECT_EQ(1, database_size);
385 tracker->DatabaseClosed(kOrigin1, kDB1);
387 // Remove an observer; this should clear all caches.
388 tracker->RemoveObserver(&observer2);
390 // Close the tracker database and clear all caches.
391 // Then make sure that DatabaseOpened() still returns the correct result.
392 tracker->CloseTrackerDatabaseAndClearCaches();
393 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
395 EXPECT_EQ(1, database_size);
396 tracker->DatabaseClosed(kOrigin1, kDB1);
398 // Remove all observers.
399 tracker->RemoveObserver(&observer1);
401 // Trying to delete a database in use should fail
402 tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
404 EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
405 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
406 EXPECT_TRUE(origin1_info);
407 EXPECT_EQ(4, origin1_info->GetDatabaseSize(kDB3));
408 tracker->DatabaseClosed(kOrigin1, kDB3);
410 // Delete a database and make sure the space used by that origin is updated
411 EXPECT_TRUE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
412 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
413 EXPECT_TRUE(origin1_info);
414 EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
415 EXPECT_EQ(0, origin1_info->GetDatabaseSize(kDB3));
417 // Get all data for all origins
418 std::vector<OriginInfo> origins_info;
419 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
420 EXPECT_EQ(size_t(2), origins_info.size());
421 EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
422 EXPECT_EQ(1, origins_info[0].TotalSize());
423 EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1));
424 EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3));
426 EXPECT_EQ(kOrigin2, origins_info[1].GetOriginIdentifier());
427 EXPECT_EQ(2, origins_info[1].TotalSize());
429 // Trying to delete an origin with databases in use should fail
430 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
432 EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
433 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
434 EXPECT_TRUE(origin1_info);
435 EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
436 tracker->DatabaseClosed(kOrigin1, kDB1);
438 // Delete an origin that doesn't have any database in use
439 EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false));
440 origins_info.clear();
441 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
442 EXPECT_EQ(size_t(1), origins_info.size());
443 EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier());
445 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
446 EXPECT_TRUE(origin1_info);
447 EXPECT_EQ(0, origin1_info->TotalSize());
450 static void DatabaseTrackerQuotaIntegration() {
451 const GURL kOrigin(kOrigin1Url);
452 const std::string kOriginId =
453 webkit_database::GetIdentifierFromOrigin(kOrigin);
454 const base::string16 kName = ASCIIToUTF16("name");
455 const base::string16 kDescription = ASCIIToUTF16("description");
457 base::ScopedTempDir temp_dir;
458 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
460 // Initialize the tracker with a QuotaManagerProxy
461 scoped_refptr<TestQuotaManagerProxy> test_quota_proxy(
462 new TestQuotaManagerProxy);
463 scoped_refptr<DatabaseTracker> tracker(
464 new DatabaseTracker(temp_dir.path(),
465 false /* incognito */,
467 test_quota_proxy.get(),
469 EXPECT_TRUE(test_quota_proxy->registered_client_);
471 // Create a database and modify it a couple of times, close it,
472 // then delete it. Observe the tracker notifies accordingly.
474 int64 database_size = 0;
475 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
477 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
478 test_quota_proxy->reset();
480 base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
481 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
482 EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
483 tracker->DatabaseModified(kOriginId, kName);
484 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
485 test_quota_proxy->reset();
487 EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
488 tracker->DatabaseModified(kOriginId, kName);
489 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
490 test_quota_proxy->reset();
492 tracker->DatabaseClosed(kOriginId, kName);
493 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
494 EXPECT_EQ(net::OK, tracker->DeleteDatabase(
495 kOriginId, kName, net::CompletionCallback()));
496 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
497 test_quota_proxy->reset();
499 // Create a database and modify it, try to delete it while open,
500 // then close it (at which time deletion will actually occur).
501 // Observe the tracker notifies accordingly.
503 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
505 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
506 test_quota_proxy->reset();
508 db_file = tracker->GetFullDBFilePath(kOriginId, kName);
509 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
510 EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
511 tracker->DatabaseModified(kOriginId, kName);
512 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
513 test_quota_proxy->reset();
515 EXPECT_EQ(net::ERR_IO_PENDING,
516 tracker->DeleteDatabase(kOriginId, kName,
517 net::CompletionCallback()));
518 EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
520 tracker->DatabaseClosed(kOriginId, kName);
521 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
522 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
523 test_quota_proxy->reset();
525 // Create a database and up the file size without telling
526 // the tracker about the modification, than simulate a
528 // Observe the tracker notifies accordingly.
530 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
532 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
533 test_quota_proxy->reset();
534 db_file = tracker->GetFullDBFilePath(kOriginId, kName);
535 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
536 EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
537 DatabaseConnections crashed_renderer_connections;
538 crashed_renderer_connections.AddConnection(kOriginId, kName);
539 EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
540 tracker->CloseDatabases(crashed_renderer_connections);
541 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
544 crashed_renderer_connections.RemoveAllConnections();
545 test_quota_proxy->SimulateQuotaManagerDestroyed();
548 static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() {
549 int64 database_size = 0;
550 const std::string kOrigin1 =
551 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
552 const std::string kOrigin2 =
553 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
554 const base::string16 kDB1 = ASCIIToUTF16("db1");
555 const base::string16 kDB2 = ASCIIToUTF16("db2");
556 const base::string16 kDescription = ASCIIToUTF16("database_description");
558 // Initialize the tracker database.
559 base::MessageLoop message_loop;
560 base::ScopedTempDir temp_dir;
561 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
562 base::FilePath origin1_db_dir;
563 base::FilePath origin2_db_dir;
565 scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
566 new quota::MockSpecialStoragePolicy;
567 special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
568 scoped_refptr<DatabaseTracker> tracker(
569 new DatabaseTracker(temp_dir.path(),
571 special_storage_policy.get(),
573 base::MessageLoopProxy::current().get()));
575 // Open two new databases.
576 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
578 EXPECT_EQ(0, database_size);
579 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
581 EXPECT_EQ(0, database_size);
583 // Write some data to each file.
584 base::FilePath db_file;
585 db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
586 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
587 EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
589 db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
590 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
591 EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
593 // Store the origin database directories as long as they still exist.
594 origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
595 origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
597 tracker->DatabaseModified(kOrigin1, kDB1);
598 tracker->DatabaseModified(kOrigin2, kDB2);
600 // Close all databases.
601 tracker->DatabaseClosed(kOrigin1, kDB1);
602 tracker->DatabaseClosed(kOrigin2, kDB2);
607 // At this point, the database tracker should be gone. Create a new one.
608 scoped_refptr<DatabaseTracker> tracker(
609 new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
611 // Get all data for all origins.
612 std::vector<OriginInfo> origins_info;
613 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
614 // kOrigin1 was not session-only, so it survived. kOrigin2 was session-only
615 // and it got deleted.
616 EXPECT_EQ(size_t(1), origins_info.size());
617 EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
619 base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
620 EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
622 // The origin directory of kOrigin1 remains, but the origin directory of
623 // kOrigin2 is deleted.
624 EXPECT_TRUE(base::PathExists(origin1_db_dir));
625 EXPECT_FALSE(base::PathExists(origin2_db_dir));
628 static void DatabaseTrackerSetForceKeepSessionState() {
629 int64 database_size = 0;
630 const std::string kOrigin1 =
631 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
632 const std::string kOrigin2 =
633 webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
634 const base::string16 kDB1 = ASCIIToUTF16("db1");
635 const base::string16 kDB2 = ASCIIToUTF16("db2");
636 const base::string16 kDescription = ASCIIToUTF16("database_description");
638 // Initialize the tracker database.
639 base::MessageLoop message_loop;
640 base::ScopedTempDir temp_dir;
641 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
642 base::FilePath origin1_db_dir;
643 base::FilePath origin2_db_dir;
645 scoped_refptr<quota::MockSpecialStoragePolicy> special_storage_policy =
646 new quota::MockSpecialStoragePolicy;
647 special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
648 scoped_refptr<DatabaseTracker> tracker(
649 new DatabaseTracker(temp_dir.path(),
651 special_storage_policy.get(),
653 base::MessageLoopProxy::current().get()));
654 tracker->SetForceKeepSessionState();
656 // Open two new databases.
657 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
659 EXPECT_EQ(0, database_size);
660 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
662 EXPECT_EQ(0, database_size);
664 // Write some data to each file.
665 base::FilePath db_file;
666 db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
667 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
668 EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
670 db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
671 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
672 EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
674 // Store the origin database directories as long as they still exist.
675 origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
676 origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
678 tracker->DatabaseModified(kOrigin1, kDB1);
679 tracker->DatabaseModified(kOrigin2, kDB2);
681 // Close all databases.
682 tracker->DatabaseClosed(kOrigin1, kDB1);
683 tracker->DatabaseClosed(kOrigin2, kDB2);
688 // At this point, the database tracker should be gone. Create a new one.
689 scoped_refptr<DatabaseTracker> tracker(
690 new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
692 // Get all data for all origins.
693 std::vector<OriginInfo> origins_info;
694 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
695 // No origins were deleted.
696 EXPECT_EQ(size_t(2), origins_info.size());
698 base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
700 base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
702 EXPECT_TRUE(base::PathExists(origin1_db_dir));
703 EXPECT_TRUE(base::PathExists(origin2_db_dir));
706 static void EmptyDatabaseNameIsValid() {
707 const GURL kOrigin(kOrigin1Url);
708 const std::string kOriginId =
709 webkit_database::GetIdentifierFromOrigin(kOrigin);
710 const base::string16 kEmptyName;
711 const base::string16 kDescription(ASCIIToUTF16("description"));
712 const base::string16 kChangedDescription(
713 ASCIIToUTF16("changed_description"));
715 // Initialize a tracker database, no need to put it on disk.
716 const bool kUseInMemoryTrackerDatabase = true;
717 base::ScopedTempDir temp_dir;
718 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
719 scoped_refptr<DatabaseTracker> tracker(
720 new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
723 // Starts off with no databases.
724 std::vector<OriginInfo> infos;
725 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
726 EXPECT_TRUE(infos.empty());
728 // Create a db with an empty name.
729 int64 database_size = -1;
730 tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
732 EXPECT_EQ(0, database_size);
733 tracker->DatabaseModified(kOriginId, kEmptyName);
734 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
735 EXPECT_EQ(1u, infos.size());
736 EXPECT_EQ(kDescription, infos[0].GetDatabaseDescription(kEmptyName));
737 EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
738 tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
741 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
742 EXPECT_EQ(1u, infos.size());
743 EXPECT_EQ(kChangedDescription, infos[0].GetDatabaseDescription(kEmptyName));
744 tracker->DatabaseClosed(kOriginId, kEmptyName);
745 tracker->DatabaseClosed(kOriginId, kEmptyName);
747 // Deleting it should return to the initial state.
748 EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kEmptyName,
749 net::CompletionCallback()));
751 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
752 EXPECT_TRUE(infos.empty());
755 static void HandleSqliteError() {
756 const GURL kOrigin(kOrigin1Url);
757 const std::string kOriginId =
758 webkit_database::GetIdentifierFromOrigin(kOrigin);
759 const base::string16 kName(ASCIIToUTF16("name"));
760 const base::string16 kDescription(ASCIIToUTF16("description"));
762 // Initialize a tracker database, no need to put it on disk.
763 const bool kUseInMemoryTrackerDatabase = true;
764 base::ScopedTempDir temp_dir;
765 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
766 scoped_refptr<DatabaseTracker> tracker(
767 new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
770 // Setup to observe OnScheduledForDelete notifications.
771 TestObserver observer(false, true);
772 tracker->AddObserver(&observer);
774 // Verify does no harm when there is no such database.
775 tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
776 EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
777 EXPECT_FALSE(observer.DidReceiveNewNotification());
779 // --------------------------------------------------------
780 // Create a record of a database in the tracker db and create
781 // a spoof_db_file on disk in the expected location.
782 int64 database_size = 0;
783 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
785 base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
786 EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
787 EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName()));
788 EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
790 // Verify does no harm with a non-error is reported.
791 tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
792 EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
793 EXPECT_FALSE(observer.DidReceiveNewNotification());
795 // Verify that with a connection open, the db is scheduled for deletion,
796 // but that the file still exists.
797 tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
798 EXPECT_TRUE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
799 EXPECT_TRUE(observer.DidReceiveNewNotification());
800 EXPECT_TRUE(base::PathExists(spoof_db_file));
802 // Verify that once closed, the file is deleted and the record in the
803 // tracker db is removed.
804 tracker->DatabaseClosed(kOriginId, kName);
805 EXPECT_FALSE(base::PathExists(spoof_db_file));
806 EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
808 // --------------------------------------------------------
809 // Create another record of a database in the tracker db and create
810 // a spoof_db_file on disk in the expected location.
811 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
813 base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId, kName);
814 EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
815 EXPECT_NE(spoof_db_file, spoof_db_file2);
816 EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName()));
817 EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
819 // Verify that with no connection open, the db is deleted immediately.
820 tracker->DatabaseClosed(kOriginId, kName);
821 tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
822 EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
823 EXPECT_FALSE(observer.DidReceiveNewNotification());
824 EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
825 EXPECT_FALSE(base::PathExists(spoof_db_file2));
827 tracker->RemoveObserver(&observer);
831 TEST(DatabaseTrackerTest, DeleteOpenDatabase) {
832 DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(false);
835 TEST(DatabaseTrackerTest, DeleteOpenDatabaseIncognitoMode) {
836 DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(true);
839 TEST(DatabaseTrackerTest, DatabaseTracker) {
840 DatabaseTracker_TestHelper_Test::TestDatabaseTracker(false);
843 TEST(DatabaseTrackerTest, DatabaseTrackerIncognitoMode) {
844 DatabaseTracker_TestHelper_Test::TestDatabaseTracker(true);
847 TEST(DatabaseTrackerTest, DatabaseTrackerQuotaIntegration) {
848 // There is no difference in behavior between incognito and not.
849 DatabaseTracker_TestHelper_Test::DatabaseTrackerQuotaIntegration();
852 TEST(DatabaseTrackerTest, DatabaseTrackerClearSessionOnlyDatabasesOnExit) {
853 // Only works for regular mode.
854 DatabaseTracker_TestHelper_Test::
855 DatabaseTrackerClearSessionOnlyDatabasesOnExit();
858 TEST(DatabaseTrackerTest, DatabaseTrackerSetForceKeepSessionState) {
859 // Only works for regular mode.
860 DatabaseTracker_TestHelper_Test::DatabaseTrackerSetForceKeepSessionState();
863 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
864 DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
867 TEST(DatabaseTrackerTest, HandleSqliteError) {
868 DatabaseTracker_TestHelper_Test::HandleSqliteError();
871 } // namespace webkit_database