blob: 14557de29c85f2372b8ae0ea72b17f7a76668e59 [file] [log] [blame]
[email protected]523e5c592014-04-30 21:46:251// Copyright 2014 The Chromium Authors. All rights reserved.
[email protected]615dedfc2009-11-02 21:41:562// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
[email protected]a6d14f72014-02-18 17:26:485#include "base/files/file.h"
[email protected]57999812013-02-24 05:40:526#include "base/files/file_path.h"
thestigb7aad54f2014-09-05 18:25:397#include "base/files/file_util.h"
[email protected]ea1a3f62012-11-16 20:34:238#include "base/files/scoped_temp_dir.h"
[email protected]3b63f8f42011-03-28 01:54:159#include "base/memory/scoped_ptr.h"
[email protected]c41ea852013-07-18 04:20:5710#include "base/message_loop/message_loop.h"
[email protected]7ccb7072013-06-10 20:56:2811#include "base/message_loop/message_loop_proxy.h"
[email protected]906265872013-06-07 22:40:4512#include "base/strings/utf_string_conversions.h"
[email protected]0a8ebe12013-06-28 15:23:2313#include "base/time/time.h"
[email protected]523e5c592014-04-30 21:46:2514#include "content/public/test/mock_special_storage_policy.h"
[email protected]ad74a592011-01-21 18:40:5515#include "net/base/net_errors.h"
[email protected]ec3d1452010-02-18 10:02:2616#include "net/base/test_completion_callback.h"
pilgrime92c5fcd2014-09-10 23:31:2317#include "storage/browser/database/database_tracker.h"
18#include "storage/browser/quota/quota_manager_proxy.h"
pilgrim16330552014-09-10 01:32:2219#include "storage/common/database/database_identifier.h"
[email protected]615dedfc2009-11-02 21:41:5620#include "testing/gtest/include/gtest/gtest.h"
[email protected]1f1db252012-02-18 01:04:1421#include "third_party/sqlite/sqlite3.h"
[email protected]615dedfc2009-11-02 21:41:5622
[email protected]f729d7a2013-12-26 07:07:5623using base::ASCIIToUTF16;
[email protected]cd501a72014-08-22 19:58:3124using storage::DatabaseConnections;
25using storage::DatabaseTracker;
26using storage::OriginInfo;
[email protected]6c3bf032013-12-25 19:37:0327
[email protected]615dedfc2009-11-02 21:41:5628namespace {
29
[email protected]19eb80152011-02-26 00:28:4330const char kOrigin1Url[] = "http://origin1";
31const char kOrigin2Url[] = "http://protected_origin2";
32
[email protected]cd501a72014-08-22 19:58:3133class TestObserver : public storage::DatabaseTracker::Observer {
[email protected]615dedfc2009-11-02 21:41:5634 public:
[email protected]1f1db252012-02-18 01:04:1435 TestObserver()
36 : new_notification_received_(false),
37 observe_size_changes_(true),
38 observe_scheduled_deletions_(true) {
39 }
40 TestObserver(bool observe_size_changes, bool observe_scheduled_deletions)
41 : new_notification_received_(false),
42 observe_size_changes_(observe_size_changes),
43 observe_scheduled_deletions_(observe_scheduled_deletions) {
44 }
45
dchengc2282aa2014-10-21 12:07:5846 ~TestObserver() override {}
47 void OnDatabaseSizeChanged(const std::string& origin_identifier,
48 const base::string16& database_name,
49 int64 database_size) override {
[email protected]1f1db252012-02-18 01:04:1450 if (!observe_size_changes_)
51 return;
[email protected]615dedfc2009-11-02 21:41:5652 new_notification_received_ = true;
53 origin_identifier_ = origin_identifier;
54 database_name_ = database_name;
55 database_size_ = database_size;
[email protected]615dedfc2009-11-02 21:41:5656 }
dchengc2282aa2014-10-21 12:07:5857 void OnDatabaseScheduledForDeletion(
[email protected]5e301592013-06-18 06:36:0558 const std::string& origin_identifier,
mohan.reddy7fc3ac72014-10-09 05:24:1359 const base::string16& database_name) override {
[email protected]1f1db252012-02-18 01:04:1460 if (!observe_scheduled_deletions_)
61 return;
[email protected]ec3d1452010-02-18 10:02:2662 new_notification_received_ = true;
63 origin_identifier_ = origin_identifier;
64 database_name_ = database_name;
[email protected]2b0ec8b2010-02-12 19:24:0465 }
[email protected]615dedfc2009-11-02 21:41:5666 bool DidReceiveNewNotification() {
67 bool temp_new_notification_received = new_notification_received_;
68 new_notification_received_ = false;
69 return temp_new_notification_received;
70 }
[email protected]5e301592013-06-18 06:36:0571 std::string GetNotificationOriginIdentifier() {
[email protected]82758352013-03-29 19:21:3172 return origin_identifier_;
73 }
74 base::string16 GetNotificationDatabaseName() { return database_name_; }
[email protected]615dedfc2009-11-02 21:41:5675 int64 GetNotificationDatabaseSize() { return database_size_; }
[email protected]615dedfc2009-11-02 21:41:5676
77 private:
78 bool new_notification_received_;
[email protected]1f1db252012-02-18 01:04:1479 bool observe_size_changes_;
80 bool observe_scheduled_deletions_;
[email protected]5e301592013-06-18 06:36:0581 std::string origin_identifier_;
[email protected]82758352013-03-29 19:21:3182 base::string16 database_name_;
[email protected]615dedfc2009-11-02 21:41:5683 int64 database_size_;
[email protected]615dedfc2009-11-02 21:41:5684};
85
86void CheckNotificationReceived(TestObserver* observer,
[email protected]5e301592013-06-18 06:36:0587 const std::string& expected_origin_identifier,
[email protected]82758352013-03-29 19:21:3188 const base::string16& expected_database_name,
[email protected]7c5f2ec2011-05-26 19:15:2689 int64 expected_database_size) {
[email protected]615dedfc2009-11-02 21:41:5690 EXPECT_TRUE(observer->DidReceiveNewNotification());
91 EXPECT_EQ(expected_origin_identifier,
92 observer->GetNotificationOriginIdentifier());
93 EXPECT_EQ(expected_database_name,
94 observer->GetNotificationDatabaseName());
95 EXPECT_EQ(expected_database_size,
96 observer->GetNotificationDatabaseSize());
[email protected]615dedfc2009-11-02 21:41:5697}
98
[email protected]cd501a72014-08-22 19:58:3199class TestQuotaManagerProxy : public storage::QuotaManagerProxy {
[email protected]eea70ad2011-05-15 00:24:13100 public:
101 TestQuotaManagerProxy()
102 : QuotaManagerProxy(NULL, NULL),
103 registered_client_(NULL) {
104 }
105
dchengc2282aa2014-10-21 12:07:58106 void RegisterClient(storage::QuotaClient* client) override {
[email protected]eea70ad2011-05-15 00:24:13107 EXPECT_FALSE(registered_client_);
108 registered_client_ = client;
109 }
110
dchengc2282aa2014-10-21 12:07:58111 void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
112 const GURL& origin,
113 storage::StorageType type) override {
[email protected]cd501a72014-08-22 19:58:31114 EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
115 EXPECT_EQ(storage::kStorageTypeTemporary, type);
[email protected]eea70ad2011-05-15 00:24:13116 accesses_[origin] += 1;
117 }
118
dchengc2282aa2014-10-21 12:07:58119 void NotifyStorageModified(storage::QuotaClient::ID client_id,
120 const GURL& origin,
121 storage::StorageType type,
122 int64 delta) override {
[email protected]cd501a72014-08-22 19:58:31123 EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
124 EXPECT_EQ(storage::kStorageTypeTemporary, type);
[email protected]eea70ad2011-05-15 00:24:13125 modifications_[origin].first += 1;
126 modifications_[origin].second += delta;
127 }
128
129 // Not needed for our tests.
dchengc2282aa2014-10-21 12:07:58130 void NotifyOriginInUse(const GURL& origin) override {}
131 void NotifyOriginNoLongerInUse(const GURL& origin) override {}
132 void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
133 const GURL& origin,
134 storage::StorageType type,
135 bool enabled) override {}
136 void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
137 const GURL& origin,
138 storage::StorageType type,
139 const GetUsageAndQuotaCallback& callback) override {}
[email protected]eea70ad2011-05-15 00:24:13140
141 void SimulateQuotaManagerDestroyed() {
142 if (registered_client_) {
143 registered_client_->OnQuotaManagerDestroyed();
144 registered_client_ = NULL;
145 }
146 }
147
148 bool WasAccessNotified(const GURL& origin) {
149 return accesses_[origin] != 0;
150 }
151
152 bool WasModificationNotified(const GURL& origin, int64 amount) {
153 return modifications_[origin].first != 0 &&
154 modifications_[origin].second == amount;
155 }
156
157 void reset() {
158 accesses_.clear();
159 modifications_.clear();
160 }
161
[email protected]cd501a72014-08-22 19:58:31162 storage::QuotaClient* registered_client_;
[email protected]eea70ad2011-05-15 00:24:13163
164 // Map from origin to count of access notifications.
165 std::map<GURL, int> accesses_;
166
167 // Map from origin to <count, sum of deltas>
168 std::map<GURL, std::pair<int, int64> > modifications_;
[email protected]e0ffc6f2012-04-28 07:04:36169
170 protected:
dchengc2282aa2014-10-21 12:07:58171 ~TestQuotaManagerProxy() override { EXPECT_FALSE(registered_client_); }
[email protected]eea70ad2011-05-15 00:24:13172};
173
174
[email protected]a3ef4832013-02-02 05:12:33175bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
[email protected]a6d14f72014-02-18 17:26:48176 base::File file(file_path,
177 base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
178 if (!file.IsValid())
[email protected]eea70ad2011-05-15 00:24:13179 return false;
[email protected]a6d14f72014-02-18 17:26:48180 return file.SetLength(length);
[email protected]eea70ad2011-05-15 00:24:13181}
182
[email protected]615dedfc2009-11-02 21:41:56183} // namespace
184
[email protected]523e5c592014-04-30 21:46:25185namespace content {
[email protected]615dedfc2009-11-02 21:41:56186
[email protected]fe615f32010-06-13 09:08:41187// We declare a helper class, and make it a friend of DatabaseTracker using
[email protected]523e5c592014-04-30 21:46:25188// the FORWARD_DECLARE_TEST macro, and we implement all tests we want to run as
[email protected]fe615f32010-06-13 09:08:41189// 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.
192class DatabaseTracker_TestHelper_Test {
193 public:
194 static void TestDeleteOpenDatabase(bool incognito_mode) {
195 // Initialize the tracker database.
[email protected]ea1a3f62012-11-16 20:34:23196 base::ScopedTempDir temp_dir;
[email protected]8e43e072010-07-28 21:30:34197 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
[email protected]523e5c592014-04-30 21:46:25198 scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
199 new MockSpecialStoragePolicy;
[email protected]d0240442011-08-17 09:23:00200 special_storage_policy->AddProtected(GURL(kOrigin2Url));
[email protected]fe615f32010-06-13 09:08:41201 scoped_refptr<DatabaseTracker> tracker(
[email protected]ff875be52013-06-02 23:47:38202 new DatabaseTracker(temp_dir.path(),
203 incognito_mode,
204 special_storage_policy.get(),
205 NULL,
206 NULL));
[email protected]fe615f32010-06-13 09:08:41207
208 // Create and open three databases.
209 int64 database_size = 0;
[email protected]5e301592013-06-18 06:36:05210 const std::string kOrigin1 =
[email protected]cd501a72014-08-22 19:58:31211 storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
[email protected]5e301592013-06-18 06:36:05212 const std::string kOrigin2 =
[email protected]cd501a72014-08-22 19:58:31213 storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
[email protected]82758352013-03-29 19:21:31214 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");
[email protected]fe615f32010-06-13 09:08:41218
219 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26220 &database_size);
[email protected]fe615f32010-06-13 09:08:41221 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26222 &database_size);
[email protected]fe615f32010-06-13 09:08:41223 tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26224 &database_size);
[email protected]fe615f32010-06-13 09:08:41225
[email protected]426d1c92013-12-03 20:08:54226 EXPECT_TRUE(base::CreateDirectory(
[email protected]e434fe72013-08-25 16:18:40227 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
228 tracker->GetOriginDirectory(kOrigin1)))));
[email protected]426d1c92013-12-03 20:08:54229 EXPECT_TRUE(base::CreateDirectory(
[email protected]e434fe72013-08-25 16:18:40230 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
231 tracker->GetOriginDirectory(kOrigin2)))));
[email protected]e5c2a22e2014-03-06 20:42:30232 EXPECT_EQ(1, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41233 tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
[email protected]e5c2a22e2014-03-06 20:42:30234 EXPECT_EQ(2, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41235 tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
[email protected]e5c2a22e2014-03-06 20:42:30236 EXPECT_EQ(3, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41237 tracker->GetFullDBFilePath(kOrigin2, kDB3), "aaa", 3));
238 tracker->DatabaseModified(kOrigin1, kDB1);
239 tracker->DatabaseModified(kOrigin2, kDB2);
240 tracker->DatabaseModified(kOrigin2, kDB3);
241
242 // Delete db1. Should also delete origin1.
243 TestObserver observer;
244 tracker->AddObserver(&observer);
[email protected]00bbe1662011-12-22 02:25:21245 net::TestCompletionCallback callback;
246 int result = tracker->DeleteDatabase(kOrigin1, kDB1, callback.callback());
[email protected]fe615f32010-06-13 09:08:41247 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);
[email protected]7567484142013-07-11 17:36:07255 EXPECT_FALSE(base::PathExists(
[email protected]5e301592013-06-18 06:36:05256 tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
[email protected]fe615f32010-06-13 09:08:41257
258 // Recreate db1.
259 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26260 &database_size);
[email protected]426d1c92013-12-03 20:08:54261 EXPECT_TRUE(base::CreateDirectory(
[email protected]e434fe72013-08-25 16:18:40262 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
263 tracker->GetOriginDirectory(kOrigin1)))));
[email protected]e5c2a22e2014-03-06 20:42:30264 EXPECT_EQ(1, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41265 tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
266 tracker->DatabaseModified(kOrigin1, kDB1);
267
268 // Setup file modification times. db1 and db2 are modified now, db3 three
269 // days ago.
[email protected]c0d508162013-12-04 22:49:00270 base::Time now = base::Time::Now();
271 EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin1, kDB1),
272 now, now));
273 EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB2),
274 now, now));
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));
[email protected]fe615f32010-06-13 09:08:41278
[email protected]654512b2010-09-01 02:09:42279 // Delete databases modified since yesterday. db2 is whitelisted.
[email protected]fe615f32010-06-13 09:08:41280 base::Time yesterday = base::Time::Now();
281 yesterday -= base::TimeDelta::FromDays(1);
[email protected]654512b2010-09-01 02:09:42282 result = tracker->DeleteDataModifiedSince(
[email protected]00bbe1662011-12-22 02:25:21283 yesterday, callback.callback());
[email protected]fe615f32010-06-13 09:08:41284 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);
[email protected]7567484142013-07-11 17:36:07291 EXPECT_FALSE(base::PathExists(
[email protected]5e301592013-06-18 06:36:05292 tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
[email protected]654512b2010-09-01 02:09:42293 EXPECT_TRUE(
[email protected]7567484142013-07-11 17:36:07294 base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
[email protected]fe615f32010-06-13 09:08:41295 EXPECT_TRUE(
[email protected]7567484142013-07-11 17:36:07296 base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
[email protected]fe615f32010-06-13 09:08:41297
298 tracker->DatabaseClosed(kOrigin2, kDB3);
299 tracker->RemoveObserver(&observer);
300 }
301
302 static void TestDatabaseTracker(bool incognito_mode) {
303 // Initialize the tracker database.
[email protected]ea1a3f62012-11-16 20:34:23304 base::ScopedTempDir temp_dir;
[email protected]8e43e072010-07-28 21:30:34305 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
[email protected]523e5c592014-04-30 21:46:25306 scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
307 new MockSpecialStoragePolicy;
[email protected]d0240442011-08-17 09:23:00308 special_storage_policy->AddProtected(GURL(kOrigin2Url));
[email protected]fe615f32010-06-13 09:08:41309 scoped_refptr<DatabaseTracker> tracker(
[email protected]ff875be52013-06-02 23:47:38310 new DatabaseTracker(temp_dir.path(),
311 incognito_mode,
312 special_storage_policy.get(),
313 NULL,
314 NULL));
[email protected]fe615f32010-06-13 09:08:41315
316 // Add two observers.
317 TestObserver observer1;
318 TestObserver observer2;
319 tracker->AddObserver(&observer1);
320 tracker->AddObserver(&observer2);
321
322 // Open three new databases.
323 int64 database_size = 0;
[email protected]5e301592013-06-18 06:36:05324 const std::string kOrigin1 =
[email protected]cd501a72014-08-22 19:58:31325 storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
[email protected]5e301592013-06-18 06:36:05326 const std::string kOrigin2 =
[email protected]cd501a72014-08-22 19:58:31327 storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
[email protected]82758352013-03-29 19:21:31328 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");
[email protected]fe615f32010-06-13 09:08:41332
[email protected]7c5f2ec2011-05-26 19:15:26333 // Get the info for kOrigin1 and kOrigin2
[email protected]fe615f32010-06-13 09:08:41334 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);
[email protected]fe615f32010-06-13 09:08:41340
[email protected]fe615f32010-06-13 09:08:41341
342 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26343 &database_size);
[email protected]fe615f32010-06-13 09:08:41344 EXPECT_EQ(0, database_size);
[email protected]fe615f32010-06-13 09:08:41345 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26346 &database_size);
[email protected]fe615f32010-06-13 09:08:41347 EXPECT_EQ(0, database_size);
[email protected]fe615f32010-06-13 09:08:41348 tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26349 &database_size);
[email protected]fe615f32010-06-13 09:08:41350 EXPECT_EQ(0, database_size);
[email protected]fe615f32010-06-13 09:08:41351
352 // Write some data to each file and check that the listeners are
353 // called with the appropriate values.
[email protected]426d1c92013-12-03 20:08:54354 EXPECT_TRUE(base::CreateDirectory(
[email protected]e434fe72013-08-25 16:18:40355 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
356 tracker->GetOriginDirectory(kOrigin1)))));
[email protected]426d1c92013-12-03 20:08:54357 EXPECT_TRUE(base::CreateDirectory(
[email protected]e434fe72013-08-25 16:18:40358 tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
359 tracker->GetOriginDirectory(kOrigin2)))));
[email protected]e5c2a22e2014-03-06 20:42:30360 EXPECT_EQ(1, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41361 tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
[email protected]e5c2a22e2014-03-06 20:42:30362 EXPECT_EQ(2, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41363 tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
[email protected]e5c2a22e2014-03-06 20:42:30364 EXPECT_EQ(4, base::WriteFile(
[email protected]fe615f32010-06-13 09:08:41365 tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa", 4));
366 tracker->DatabaseModified(kOrigin1, kDB1);
[email protected]7c5f2ec2011-05-26 19:15:26367 CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1);
368 CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1);
[email protected]fe615f32010-06-13 09:08:41369 tracker->DatabaseModified(kOrigin2, kDB2);
[email protected]7c5f2ec2011-05-26 19:15:26370 CheckNotificationReceived(&observer1, kOrigin2, kDB2, 2);
371 CheckNotificationReceived(&observer2, kOrigin2, kDB2, 2);
[email protected]fe615f32010-06-13 09:08:41372 tracker->DatabaseModified(kOrigin1, kDB3);
[email protected]7c5f2ec2011-05-26 19:15:26373 CheckNotificationReceived(&observer1, kOrigin1, kDB3, 4);
374 CheckNotificationReceived(&observer2, kOrigin1, kDB3, 4);
[email protected]fe615f32010-06-13 09:08:41375
376 // Close all databases
377 tracker->DatabaseClosed(kOrigin1, kDB1);
378 tracker->DatabaseClosed(kOrigin2, kDB2);
379 tracker->DatabaseClosed(kOrigin1, kDB3);
380
381 // Open an existing database and check the reported size
382 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26383 &database_size);
[email protected]fe615f32010-06-13 09:08:41384 EXPECT_EQ(1, database_size);
[email protected]fe615f32010-06-13 09:08:41385 tracker->DatabaseClosed(kOrigin1, kDB1);
386
387 // Remove an observer; this should clear all caches.
388 tracker->RemoveObserver(&observer2);
389
[email protected]fe615f32010-06-13 09:08:41390 // 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,
[email protected]7c5f2ec2011-05-26 19:15:26394 &database_size);
395 EXPECT_EQ(1, database_size);
[email protected]fe615f32010-06-13 09:08:41396 tracker->DatabaseClosed(kOrigin1, kDB1);
397
398 // Remove all observers.
399 tracker->RemoveObserver(&observer1);
400
401 // Trying to delete a database in use should fail
402 tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26403 &database_size);
[email protected]fe615f32010-06-13 09:08:41404 EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
405 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
406 EXPECT_TRUE(origin1_info);
[email protected]7c5f2ec2011-05-26 19:15:26407 EXPECT_EQ(4, origin1_info->GetDatabaseSize(kDB3));
[email protected]fe615f32010-06-13 09:08:41408 tracker->DatabaseClosed(kOrigin1, kDB3);
409
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);
[email protected]7c5f2ec2011-05-26 19:15:26414 EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
[email protected]fe615f32010-06-13 09:08:41415 EXPECT_EQ(0, origin1_info->GetDatabaseSize(kDB3));
416
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());
[email protected]5e301592013-06-18 06:36:05421 EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
[email protected]7c5f2ec2011-05-26 19:15:26422 EXPECT_EQ(1, origins_info[0].TotalSize());
423 EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1));
[email protected]fe615f32010-06-13 09:08:41424 EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3));
425
[email protected]5e301592013-06-18 06:36:05426 EXPECT_EQ(kOrigin2, origins_info[1].GetOriginIdentifier());
[email protected]fe615f32010-06-13 09:08:41427 EXPECT_EQ(2, origins_info[1].TotalSize());
[email protected]fe615f32010-06-13 09:08:41428
429 // Trying to delete an origin with databases in use should fail
430 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26431 &database_size);
[email protected]800ad562011-07-08 08:00:50432 EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
[email protected]fe615f32010-06-13 09:08:41433 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
434 EXPECT_TRUE(origin1_info);
[email protected]7c5f2ec2011-05-26 19:15:26435 EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
[email protected]fe615f32010-06-13 09:08:41436 tracker->DatabaseClosed(kOrigin1, kDB1);
437
438 // Delete an origin that doesn't have any database in use
[email protected]800ad562011-07-08 08:00:50439 EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false));
[email protected]fe615f32010-06-13 09:08:41440 origins_info.clear();
441 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
442 EXPECT_EQ(size_t(1), origins_info.size());
[email protected]5e301592013-06-18 06:36:05443 EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier());
[email protected]fe615f32010-06-13 09:08:41444
445 origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
446 EXPECT_TRUE(origin1_info);
[email protected]fe615f32010-06-13 09:08:41447 EXPECT_EQ(0, origin1_info->TotalSize());
[email protected]fe615f32010-06-13 09:08:41448 }
[email protected]eea70ad2011-05-15 00:24:13449
450 static void DatabaseTrackerQuotaIntegration() {
451 const GURL kOrigin(kOrigin1Url);
[email protected]cd501a72014-08-22 19:58:31452 const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin);
[email protected]82758352013-03-29 19:21:31453 const base::string16 kName = ASCIIToUTF16("name");
454 const base::string16 kDescription = ASCIIToUTF16("description");
[email protected]eea70ad2011-05-15 00:24:13455
[email protected]ea1a3f62012-11-16 20:34:23456 base::ScopedTempDir temp_dir;
[email protected]eea70ad2011-05-15 00:24:13457 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
458
459 // Initialize the tracker with a QuotaManagerProxy
460 scoped_refptr<TestQuotaManagerProxy> test_quota_proxy(
461 new TestQuotaManagerProxy);
462 scoped_refptr<DatabaseTracker> tracker(
[email protected]ff875be52013-06-02 23:47:38463 new DatabaseTracker(temp_dir.path(),
464 false /* incognito */,
465 NULL,
466 test_quota_proxy.get(),
467 NULL));
[email protected]eea70ad2011-05-15 00:24:13468 EXPECT_TRUE(test_quota_proxy->registered_client_);
469
470 // Create a database and modify it a couple of times, close it,
471 // then delete it. Observe the tracker notifies accordingly.
472
473 int64 database_size = 0;
[email protected]eea70ad2011-05-15 00:24:13474 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26475 &database_size);
[email protected]eea70ad2011-05-15 00:24:13476 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
477 test_quota_proxy->reset();
478
[email protected]a3ef4832013-02-02 05:12:33479 base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
[email protected]426d1c92013-12-03 20:08:54480 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]eea70ad2011-05-15 00:24:13481 EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
482 tracker->DatabaseModified(kOriginId, kName);
483 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
484 test_quota_proxy->reset();
485
486 EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
487 tracker->DatabaseModified(kOriginId, kName);
488 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
489 test_quota_proxy->reset();
490
491 tracker->DatabaseClosed(kOriginId, kName);
[email protected]7c5f2ec2011-05-26 19:15:26492 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
[email protected]00bbe1662011-12-22 02:25:21493 EXPECT_EQ(net::OK, tracker->DeleteDatabase(
494 kOriginId, kName, net::CompletionCallback()));
[email protected]eea70ad2011-05-15 00:24:13495 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
[email protected]7c5f2ec2011-05-26 19:15:26496 test_quota_proxy->reset();
[email protected]eea70ad2011-05-15 00:24:13497
498 // Create a database and modify it, try to delete it while open,
499 // then close it (at which time deletion will actually occur).
500 // Observe the tracker notifies accordingly.
501
502 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26503 &database_size);
[email protected]eea70ad2011-05-15 00:24:13504 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
505 test_quota_proxy->reset();
506
507 db_file = tracker->GetFullDBFilePath(kOriginId, kName);
[email protected]426d1c92013-12-03 20:08:54508 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]eea70ad2011-05-15 00:24:13509 EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
510 tracker->DatabaseModified(kOriginId, kName);
511 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
512 test_quota_proxy->reset();
513
514 EXPECT_EQ(net::ERR_IO_PENDING,
[email protected]00bbe1662011-12-22 02:25:21515 tracker->DeleteDatabase(kOriginId, kName,
516 net::CompletionCallback()));
[email protected]eea70ad2011-05-15 00:24:13517 EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
518
519 tracker->DatabaseClosed(kOriginId, kName);
[email protected]7c5f2ec2011-05-26 19:15:26520 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
[email protected]eea70ad2011-05-15 00:24:13521 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
[email protected]7c5f2ec2011-05-26 19:15:26522 test_quota_proxy->reset();
[email protected]eea70ad2011-05-15 00:24:13523
524 // Create a database and up the file size without telling
525 // the tracker about the modification, than simulate a
526 // a renderer crash.
527 // Observe the tracker notifies accordingly.
528
529 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
[email protected]7c5f2ec2011-05-26 19:15:26530 &database_size);
[email protected]eea70ad2011-05-15 00:24:13531 EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
532 test_quota_proxy->reset();
533 db_file = tracker->GetFullDBFilePath(kOriginId, kName);
[email protected]426d1c92013-12-03 20:08:54534 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]eea70ad2011-05-15 00:24:13535 EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
536 DatabaseConnections crashed_renderer_connections;
537 crashed_renderer_connections.AddConnection(kOriginId, kName);
538 EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
539 tracker->CloseDatabases(crashed_renderer_connections);
540 EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
541
542 // Cleanup.
543 crashed_renderer_connections.RemoveAllConnections();
544 test_quota_proxy->SimulateQuotaManagerDestroyed();
545 }
[email protected]800ad562011-07-08 08:00:50546
[email protected]f5d75f72011-09-08 11:31:40547 static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() {
548 int64 database_size = 0;
[email protected]5e301592013-06-18 06:36:05549 const std::string kOrigin1 =
[email protected]cd501a72014-08-22 19:58:31550 storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
[email protected]5e301592013-06-18 06:36:05551 const std::string kOrigin2 =
[email protected]cd501a72014-08-22 19:58:31552 storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
[email protected]82758352013-03-29 19:21:31553 const base::string16 kDB1 = ASCIIToUTF16("db1");
554 const base::string16 kDB2 = ASCIIToUTF16("db2");
555 const base::string16 kDescription = ASCIIToUTF16("database_description");
[email protected]f5d75f72011-09-08 11:31:40556
557 // Initialize the tracker database.
[email protected]4cc586b2013-05-07 12:43:32558 base::MessageLoop message_loop;
[email protected]ea1a3f62012-11-16 20:34:23559 base::ScopedTempDir temp_dir;
[email protected]f5d75f72011-09-08 11:31:40560 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
[email protected]a3ef4832013-02-02 05:12:33561 base::FilePath origin1_db_dir;
562 base::FilePath origin2_db_dir;
[email protected]f5d75f72011-09-08 11:31:40563 {
[email protected]523e5c592014-04-30 21:46:25564 scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
565 new MockSpecialStoragePolicy;
[email protected]f5d75f72011-09-08 11:31:40566 special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
567 scoped_refptr<DatabaseTracker> tracker(
[email protected]ff875be52013-06-02 23:47:38568 new DatabaseTracker(temp_dir.path(),
569 false,
570 special_storage_policy.get(),
571 NULL,
[email protected]cadac622013-06-11 16:46:36572 base::MessageLoopProxy::current().get()));
[email protected]f5d75f72011-09-08 11:31:40573
574 // Open two new databases.
575 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
576 &database_size);
577 EXPECT_EQ(0, database_size);
578 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
579 &database_size);
580 EXPECT_EQ(0, database_size);
581
582 // Write some data to each file.
[email protected]a3ef4832013-02-02 05:12:33583 base::FilePath db_file;
[email protected]f5d75f72011-09-08 11:31:40584 db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
[email protected]426d1c92013-12-03 20:08:54585 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]f5d75f72011-09-08 11:31:40586 EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
587
588 db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
[email protected]426d1c92013-12-03 20:08:54589 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]f5d75f72011-09-08 11:31:40590 EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
591
592 // Store the origin database directories as long as they still exist.
593 origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
594 origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
595
596 tracker->DatabaseModified(kOrigin1, kDB1);
597 tracker->DatabaseModified(kOrigin2, kDB2);
598
599 // Close all databases.
600 tracker->DatabaseClosed(kOrigin1, kDB1);
601 tracker->DatabaseClosed(kOrigin2, kDB2);
602
603 tracker->Shutdown();
604 }
605
606 // At this point, the database tracker should be gone. Create a new one.
607 scoped_refptr<DatabaseTracker> tracker(
[email protected]142dd752012-02-27 22:27:41608 new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
[email protected]f5d75f72011-09-08 11:31:40609
610 // Get all data for all origins.
611 std::vector<OriginInfo> origins_info;
612 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
613 // kOrigin1 was not session-only, so it survived. kOrigin2 was session-only
614 // and it got deleted.
615 EXPECT_EQ(size_t(1), origins_info.size());
[email protected]5e301592013-06-18 06:36:05616 EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
[email protected]f5d75f72011-09-08 11:31:40617 EXPECT_TRUE(
[email protected]7567484142013-07-11 17:36:07618 base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
[email protected]a3ef4832013-02-02 05:12:33619 EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
[email protected]f5d75f72011-09-08 11:31:40620
621 // The origin directory of kOrigin1 remains, but the origin directory of
622 // kOrigin2 is deleted.
[email protected]7567484142013-07-11 17:36:07623 EXPECT_TRUE(base::PathExists(origin1_db_dir));
624 EXPECT_FALSE(base::PathExists(origin2_db_dir));
[email protected]f5d75f72011-09-08 11:31:40625 }
626
[email protected]bf510ed2012-06-05 08:31:43627 static void DatabaseTrackerSetForceKeepSessionState() {
[email protected]e9005772011-12-08 10:44:03628 int64 database_size = 0;
[email protected]5e301592013-06-18 06:36:05629 const std::string kOrigin1 =
[email protected]cd501a72014-08-22 19:58:31630 storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
[email protected]5e301592013-06-18 06:36:05631 const std::string kOrigin2 =
[email protected]cd501a72014-08-22 19:58:31632 storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
[email protected]82758352013-03-29 19:21:31633 const base::string16 kDB1 = ASCIIToUTF16("db1");
634 const base::string16 kDB2 = ASCIIToUTF16("db2");
635 const base::string16 kDescription = ASCIIToUTF16("database_description");
[email protected]e9005772011-12-08 10:44:03636
637 // Initialize the tracker database.
[email protected]4cc586b2013-05-07 12:43:32638 base::MessageLoop message_loop;
[email protected]ea1a3f62012-11-16 20:34:23639 base::ScopedTempDir temp_dir;
[email protected]e9005772011-12-08 10:44:03640 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
[email protected]a3ef4832013-02-02 05:12:33641 base::FilePath origin1_db_dir;
642 base::FilePath origin2_db_dir;
[email protected]e9005772011-12-08 10:44:03643 {
[email protected]523e5c592014-04-30 21:46:25644 scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
645 new MockSpecialStoragePolicy;
[email protected]e9005772011-12-08 10:44:03646 special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
647 scoped_refptr<DatabaseTracker> tracker(
[email protected]ff875be52013-06-02 23:47:38648 new DatabaseTracker(temp_dir.path(),
649 false,
650 special_storage_policy.get(),
651 NULL,
[email protected]cadac622013-06-11 16:46:36652 base::MessageLoopProxy::current().get()));
[email protected]bf510ed2012-06-05 08:31:43653 tracker->SetForceKeepSessionState();
[email protected]e9005772011-12-08 10:44:03654
655 // Open two new databases.
656 tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
657 &database_size);
658 EXPECT_EQ(0, database_size);
659 tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
660 &database_size);
661 EXPECT_EQ(0, database_size);
662
663 // Write some data to each file.
[email protected]a3ef4832013-02-02 05:12:33664 base::FilePath db_file;
[email protected]e9005772011-12-08 10:44:03665 db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
[email protected]426d1c92013-12-03 20:08:54666 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]e9005772011-12-08 10:44:03667 EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
668
669 db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
[email protected]426d1c92013-12-03 20:08:54670 EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
[email protected]e9005772011-12-08 10:44:03671 EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
672
673 // Store the origin database directories as long as they still exist.
674 origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
675 origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
676
677 tracker->DatabaseModified(kOrigin1, kDB1);
678 tracker->DatabaseModified(kOrigin2, kDB2);
679
680 // Close all databases.
681 tracker->DatabaseClosed(kOrigin1, kDB1);
682 tracker->DatabaseClosed(kOrigin2, kDB2);
683
684 tracker->Shutdown();
685 }
686
687 // At this point, the database tracker should be gone. Create a new one.
688 scoped_refptr<DatabaseTracker> tracker(
[email protected]142dd752012-02-27 22:27:41689 new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
[email protected]e9005772011-12-08 10:44:03690
691 // Get all data for all origins.
692 std::vector<OriginInfo> origins_info;
693 EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
694 // No origins were deleted.
695 EXPECT_EQ(size_t(2), origins_info.size());
696 EXPECT_TRUE(
[email protected]7567484142013-07-11 17:36:07697 base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
[email protected]e9005772011-12-08 10:44:03698 EXPECT_TRUE(
[email protected]7567484142013-07-11 17:36:07699 base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
[email protected]e9005772011-12-08 10:44:03700
[email protected]7567484142013-07-11 17:36:07701 EXPECT_TRUE(base::PathExists(origin1_db_dir));
702 EXPECT_TRUE(base::PathExists(origin2_db_dir));
[email protected]e9005772011-12-08 10:44:03703 }
704
[email protected]e5a3cdc2011-08-26 19:49:53705 static void EmptyDatabaseNameIsValid() {
706 const GURL kOrigin(kOrigin1Url);
[email protected]cd501a72014-08-22 19:58:31707 const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin);
[email protected]82758352013-03-29 19:21:31708 const base::string16 kEmptyName;
709 const base::string16 kDescription(ASCIIToUTF16("description"));
710 const base::string16 kChangedDescription(
711 ASCIIToUTF16("changed_description"));
[email protected]e5a3cdc2011-08-26 19:49:53712
713 // Initialize a tracker database, no need to put it on disk.
714 const bool kUseInMemoryTrackerDatabase = true;
[email protected]ea1a3f62012-11-16 20:34:23715 base::ScopedTempDir temp_dir;
[email protected]e5a3cdc2011-08-26 19:49:53716 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
717 scoped_refptr<DatabaseTracker> tracker(
718 new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
[email protected]142dd752012-02-27 22:27:41719 NULL, NULL, NULL));
[email protected]e5a3cdc2011-08-26 19:49:53720
721 // Starts off with no databases.
722 std::vector<OriginInfo> infos;
723 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
724 EXPECT_TRUE(infos.empty());
725
726 // Create a db with an empty name.
727 int64 database_size = -1;
728 tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
729 &database_size);
730 EXPECT_EQ(0, database_size);
731 tracker->DatabaseModified(kOriginId, kEmptyName);
732 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
733 EXPECT_EQ(1u, infos.size());
734 EXPECT_EQ(kDescription, infos[0].GetDatabaseDescription(kEmptyName));
735 EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
736 tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
737 &database_size);
738 infos.clear();
739 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
740 EXPECT_EQ(1u, infos.size());
741 EXPECT_EQ(kChangedDescription, infos[0].GetDatabaseDescription(kEmptyName));
742 tracker->DatabaseClosed(kOriginId, kEmptyName);
743 tracker->DatabaseClosed(kOriginId, kEmptyName);
744
745 // Deleting it should return to the initial state.
[email protected]00bbe1662011-12-22 02:25:21746 EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kEmptyName,
747 net::CompletionCallback()));
[email protected]e5a3cdc2011-08-26 19:49:53748 infos.clear();
749 EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
750 EXPECT_TRUE(infos.empty());
751 }
[email protected]1f1db252012-02-18 01:04:14752
753 static void HandleSqliteError() {
754 const GURL kOrigin(kOrigin1Url);
[email protected]cd501a72014-08-22 19:58:31755 const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin);
[email protected]82758352013-03-29 19:21:31756 const base::string16 kName(ASCIIToUTF16("name"));
757 const base::string16 kDescription(ASCIIToUTF16("description"));
[email protected]1f1db252012-02-18 01:04:14758
759 // Initialize a tracker database, no need to put it on disk.
760 const bool kUseInMemoryTrackerDatabase = true;
[email protected]ea1a3f62012-11-16 20:34:23761 base::ScopedTempDir temp_dir;
[email protected]1f1db252012-02-18 01:04:14762 ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
763 scoped_refptr<DatabaseTracker> tracker(
764 new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
[email protected]142dd752012-02-27 22:27:41765 NULL, NULL, NULL));
[email protected]1f1db252012-02-18 01:04:14766
767 // Setup to observe OnScheduledForDelete notifications.
768 TestObserver observer(false, true);
769 tracker->AddObserver(&observer);
770
771 // Verify does no harm when there is no such database.
772 tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
773 EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
774 EXPECT_FALSE(observer.DidReceiveNewNotification());
775
776 // --------------------------------------------------------
777 // Create a record of a database in the tracker db and create
778 // a spoof_db_file on disk in the expected location.
779 int64 database_size = 0;
780 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
781 &database_size);
[email protected]a3ef4832013-02-02 05:12:33782 base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
[email protected]1f1db252012-02-18 01:04:14783 EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
[email protected]426d1c92013-12-03 20:08:54784 EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName()));
[email protected]1f1db252012-02-18 01:04:14785 EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
786
787 // Verify does no harm with a non-error is reported.
788 tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
789 EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
790 EXPECT_FALSE(observer.DidReceiveNewNotification());
791
792 // Verify that with a connection open, the db is scheduled for deletion,
793 // but that the file still exists.
794 tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
795 EXPECT_TRUE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
796 EXPECT_TRUE(observer.DidReceiveNewNotification());
[email protected]7567484142013-07-11 17:36:07797 EXPECT_TRUE(base::PathExists(spoof_db_file));
[email protected]1f1db252012-02-18 01:04:14798
799 // Verify that once closed, the file is deleted and the record in the
800 // tracker db is removed.
801 tracker->DatabaseClosed(kOriginId, kName);
[email protected]7567484142013-07-11 17:36:07802 EXPECT_FALSE(base::PathExists(spoof_db_file));
[email protected]1f1db252012-02-18 01:04:14803 EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
804
805 // --------------------------------------------------------
806 // Create another record of a database in the tracker db and create
807 // a spoof_db_file on disk in the expected location.
808 tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
[email protected]523e5c592014-04-30 21:46:25809 &database_size);
810 base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId,
811 kName);
[email protected]1f1db252012-02-18 01:04:14812 EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
813 EXPECT_NE(spoof_db_file, spoof_db_file2);
[email protected]426d1c92013-12-03 20:08:54814 EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName()));
[email protected]1f1db252012-02-18 01:04:14815 EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
816
817 // Verify that with no connection open, the db is deleted immediately.
818 tracker->DatabaseClosed(kOriginId, kName);
819 tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
820 EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
821 EXPECT_FALSE(observer.DidReceiveNewNotification());
822 EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
[email protected]7567484142013-07-11 17:36:07823 EXPECT_FALSE(base::PathExists(spoof_db_file2));
[email protected]1f1db252012-02-18 01:04:14824
825 tracker->RemoveObserver(&observer);
826 }
[email protected]fe615f32010-06-13 09:08:41827};
828
[email protected]ec3d1452010-02-18 10:02:26829TEST(DatabaseTrackerTest, DeleteOpenDatabase) {
[email protected]fe615f32010-06-13 09:08:41830 DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(false);
831}
[email protected]ec3d1452010-02-18 10:02:26832
[email protected]fe615f32010-06-13 09:08:41833TEST(DatabaseTrackerTest, DeleteOpenDatabaseIncognitoMode) {
834 DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(true);
[email protected]ec3d1452010-02-18 10:02:26835}
836
[email protected]49cd5da2010-04-02 00:29:51837TEST(DatabaseTrackerTest, DatabaseTracker) {
[email protected]fe615f32010-06-13 09:08:41838 DatabaseTracker_TestHelper_Test::TestDatabaseTracker(false);
[email protected]615dedfc2009-11-02 21:41:56839}
840
[email protected]fe615f32010-06-13 09:08:41841TEST(DatabaseTrackerTest, DatabaseTrackerIncognitoMode) {
842 DatabaseTracker_TestHelper_Test::TestDatabaseTracker(true);
[email protected]49cd5da2010-04-02 00:29:51843}
844
[email protected]eea70ad2011-05-15 00:24:13845TEST(DatabaseTrackerTest, DatabaseTrackerQuotaIntegration) {
846 // There is no difference in behavior between incognito and not.
847 DatabaseTracker_TestHelper_Test::DatabaseTrackerQuotaIntegration();
848}
849
[email protected]f5d75f72011-09-08 11:31:40850TEST(DatabaseTrackerTest, DatabaseTrackerClearSessionOnlyDatabasesOnExit) {
851 // Only works for regular mode.
852 DatabaseTracker_TestHelper_Test::
853 DatabaseTrackerClearSessionOnlyDatabasesOnExit();
854}
855
[email protected]bf510ed2012-06-05 08:31:43856TEST(DatabaseTrackerTest, DatabaseTrackerSetForceKeepSessionState) {
[email protected]e9005772011-12-08 10:44:03857 // Only works for regular mode.
[email protected]bf510ed2012-06-05 08:31:43858 DatabaseTracker_TestHelper_Test::DatabaseTrackerSetForceKeepSessionState();
[email protected]e9005772011-12-08 10:44:03859}
860
[email protected]e5a3cdc2011-08-26 19:49:53861TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
862 DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
863}
864
[email protected]1f1db252012-02-18 01:04:14865TEST(DatabaseTrackerTest, HandleSqliteError) {
866 DatabaseTracker_TestHelper_Test::HandleSqliteError();
867}
868
[email protected]523e5c592014-04-30 21:46:25869} // namespace content