[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 1 | // Copyright 2014 The Chromium Authors. All rights reserved. |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
[email protected] | a6d14f7 | 2014-02-18 17:26:48 | [diff] [blame] | 5 | #include "base/files/file.h" |
[email protected] | 5799981 | 2013-02-24 05:40:52 | [diff] [blame] | 6 | #include "base/files/file_path.h" |
thestig | b7aad54f | 2014-09-05 18:25:39 | [diff] [blame] | 7 | #include "base/files/file_util.h" |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 8 | #include "base/files/scoped_temp_dir.h" |
[email protected] | 3b63f8f4 | 2011-03-28 01:54:15 | [diff] [blame] | 9 | #include "base/memory/scoped_ptr.h" |
[email protected] | c41ea85 | 2013-07-18 04:20:57 | [diff] [blame] | 10 | #include "base/message_loop/message_loop.h" |
[email protected] | 7ccb707 | 2013-06-10 20:56:28 | [diff] [blame] | 11 | #include "base/message_loop/message_loop_proxy.h" |
[email protected] | 90626587 | 2013-06-07 22:40:45 | [diff] [blame] | 12 | #include "base/strings/utf_string_conversions.h" |
[email protected] | 0a8ebe1 | 2013-06-28 15:23:23 | [diff] [blame] | 13 | #include "base/time/time.h" |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 14 | #include "content/public/test/mock_special_storage_policy.h" |
[email protected] | ad74a59 | 2011-01-21 18:40:55 | [diff] [blame] | 15 | #include "net/base/net_errors.h" |
[email protected] | ec3d145 | 2010-02-18 10:02:26 | [diff] [blame] | 16 | #include "net/base/test_completion_callback.h" |
pilgrim | e92c5fcd | 2014-09-10 23:31:23 | [diff] [blame] | 17 | #include "storage/browser/database/database_tracker.h" |
| 18 | #include "storage/browser/quota/quota_manager_proxy.h" |
pilgrim | 1633055 | 2014-09-10 01:32:22 | [diff] [blame] | 19 | #include "storage/common/database/database_identifier.h" |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 20 | #include "testing/gtest/include/gtest/gtest.h" |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 21 | #include "third_party/sqlite/sqlite3.h" |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 22 | |
[email protected] | f729d7a | 2013-12-26 07:07:56 | [diff] [blame] | 23 | using base::ASCIIToUTF16; |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 24 | using storage::DatabaseConnections; |
| 25 | using storage::DatabaseTracker; |
| 26 | using storage::OriginInfo; |
[email protected] | 6c3bf03 | 2013-12-25 19:37:03 | [diff] [blame] | 27 | |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 28 | namespace { |
| 29 | |
[email protected] | 19eb8015 | 2011-02-26 00:28:43 | [diff] [blame] | 30 | const char kOrigin1Url[] = "http://origin1"; |
| 31 | const char kOrigin2Url[] = "http://protected_origin2"; |
| 32 | |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 33 | class TestObserver : public storage::DatabaseTracker::Observer { |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 34 | public: |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 35 | 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 | |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 46 | ~TestObserver() override {} |
| 47 | void OnDatabaseSizeChanged(const std::string& origin_identifier, |
| 48 | const base::string16& database_name, |
| 49 | int64 database_size) override { |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 50 | if (!observe_size_changes_) |
| 51 | return; |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 52 | new_notification_received_ = true; |
| 53 | origin_identifier_ = origin_identifier; |
| 54 | database_name_ = database_name; |
| 55 | database_size_ = database_size; |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 56 | } |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 57 | void OnDatabaseScheduledForDeletion( |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 58 | const std::string& origin_identifier, |
mohan.reddy | 7fc3ac7 | 2014-10-09 05:24:13 | [diff] [blame] | 59 | const base::string16& database_name) override { |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 60 | if (!observe_scheduled_deletions_) |
| 61 | return; |
[email protected] | ec3d145 | 2010-02-18 10:02:26 | [diff] [blame] | 62 | new_notification_received_ = true; |
| 63 | origin_identifier_ = origin_identifier; |
| 64 | database_name_ = database_name; |
[email protected] | 2b0ec8b | 2010-02-12 19:24:04 | [diff] [blame] | 65 | } |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 66 | 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] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 71 | std::string GetNotificationOriginIdentifier() { |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 72 | return origin_identifier_; |
| 73 | } |
| 74 | base::string16 GetNotificationDatabaseName() { return database_name_; } |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 75 | int64 GetNotificationDatabaseSize() { return database_size_; } |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 76 | |
| 77 | private: |
| 78 | bool new_notification_received_; |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 79 | bool observe_size_changes_; |
| 80 | bool observe_scheduled_deletions_; |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 81 | std::string origin_identifier_; |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 82 | base::string16 database_name_; |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 83 | int64 database_size_; |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 84 | }; |
| 85 | |
| 86 | void CheckNotificationReceived(TestObserver* observer, |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 87 | const std::string& expected_origin_identifier, |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 88 | const base::string16& expected_database_name, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 89 | int64 expected_database_size) { |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 90 | 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] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 97 | } |
| 98 | |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 99 | class TestQuotaManagerProxy : public storage::QuotaManagerProxy { |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 100 | public: |
| 101 | TestQuotaManagerProxy() |
| 102 | : QuotaManagerProxy(NULL, NULL), |
| 103 | registered_client_(NULL) { |
| 104 | } |
| 105 | |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 106 | void RegisterClient(storage::QuotaClient* client) override { |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 107 | EXPECT_FALSE(registered_client_); |
| 108 | registered_client_ = client; |
| 109 | } |
| 110 | |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 111 | void NotifyStorageAccessed(storage::QuotaClient::ID client_id, |
| 112 | const GURL& origin, |
| 113 | storage::StorageType type) override { |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 114 | EXPECT_EQ(storage::QuotaClient::kDatabase, client_id); |
| 115 | EXPECT_EQ(storage::kStorageTypeTemporary, type); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 116 | accesses_[origin] += 1; |
| 117 | } |
| 118 | |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 119 | void NotifyStorageModified(storage::QuotaClient::ID client_id, |
| 120 | const GURL& origin, |
| 121 | storage::StorageType type, |
| 122 | int64 delta) override { |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 123 | EXPECT_EQ(storage::QuotaClient::kDatabase, client_id); |
| 124 | EXPECT_EQ(storage::kStorageTypeTemporary, type); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 125 | modifications_[origin].first += 1; |
| 126 | modifications_[origin].second += delta; |
| 127 | } |
| 128 | |
| 129 | // Not needed for our tests. |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 130 | 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] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 140 | |
| 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] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 162 | storage::QuotaClient* registered_client_; |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 163 | |
| 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] | e0ffc6f | 2012-04-28 07:04:36 | [diff] [blame] | 169 | |
| 170 | protected: |
dcheng | c2282aa | 2014-10-21 12:07:58 | [diff] [blame] | 171 | ~TestQuotaManagerProxy() override { EXPECT_FALSE(registered_client_); } |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 172 | }; |
| 173 | |
| 174 | |
[email protected] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 175 | bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) { |
[email protected] | a6d14f7 | 2014-02-18 17:26:48 | [diff] [blame] | 176 | base::File file(file_path, |
| 177 | base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE); |
| 178 | if (!file.IsValid()) |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 179 | return false; |
[email protected] | a6d14f7 | 2014-02-18 17:26:48 | [diff] [blame] | 180 | return file.SetLength(length); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 181 | } |
| 182 | |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 183 | } // namespace |
| 184 | |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 185 | namespace content { |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 186 | |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 187 | // We declare a helper class, and make it a friend of DatabaseTracker using |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 188 | // the FORWARD_DECLARE_TEST macro, and we implement all tests we want to run as |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 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 { |
| 193 | public: |
| 194 | static void TestDeleteOpenDatabase(bool incognito_mode) { |
| 195 | // Initialize the tracker database. |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 196 | base::ScopedTempDir temp_dir; |
[email protected] | 8e43e07 | 2010-07-28 21:30:34 | [diff] [blame] | 197 | ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 198 | scoped_refptr<MockSpecialStoragePolicy> special_storage_policy = |
| 199 | new MockSpecialStoragePolicy; |
[email protected] | d024044 | 2011-08-17 09:23:00 | [diff] [blame] | 200 | special_storage_policy->AddProtected(GURL(kOrigin2Url)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 201 | scoped_refptr<DatabaseTracker> tracker( |
[email protected] | ff875be5 | 2013-06-02 23:47:38 | [diff] [blame] | 202 | new DatabaseTracker(temp_dir.path(), |
| 203 | incognito_mode, |
| 204 | special_storage_policy.get(), |
| 205 | NULL, |
| 206 | NULL)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 207 | |
| 208 | // Create and open three databases. |
| 209 | int64 database_size = 0; |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 210 | const std::string kOrigin1 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 211 | storage::GetIdentifierFromOrigin(GURL(kOrigin1Url)); |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 212 | const std::string kOrigin2 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 213 | storage::GetIdentifierFromOrigin(GURL(kOrigin2Url)); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 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"); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 218 | |
| 219 | tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 220 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 221 | tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 222 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 223 | tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 224 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 225 | |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 226 | EXPECT_TRUE(base::CreateDirectory( |
[email protected] | e434fe7 | 2013-08-25 16:18:40 | [diff] [blame] | 227 | tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe( |
| 228 | tracker->GetOriginDirectory(kOrigin1))))); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 229 | EXPECT_TRUE(base::CreateDirectory( |
[email protected] | e434fe7 | 2013-08-25 16:18:40 | [diff] [blame] | 230 | tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe( |
| 231 | tracker->GetOriginDirectory(kOrigin2))))); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 232 | EXPECT_EQ(1, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 233 | tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1)); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 234 | EXPECT_EQ(2, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 235 | tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2)); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 236 | EXPECT_EQ(3, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 237 | 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] | 00bbe166 | 2011-12-22 02:25:21 | [diff] [blame] | 245 | net::TestCompletionCallback callback; |
| 246 | int result = tracker->DeleteDatabase(kOrigin1, kDB1, callback.callback()); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 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); |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 255 | EXPECT_FALSE(base::PathExists( |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 256 | tracker->DatabaseDirectory().AppendASCII(kOrigin1))); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 257 | |
| 258 | // Recreate db1. |
| 259 | tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 260 | &database_size); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 261 | EXPECT_TRUE(base::CreateDirectory( |
[email protected] | e434fe7 | 2013-08-25 16:18:40 | [diff] [blame] | 262 | tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe( |
| 263 | tracker->GetOriginDirectory(kOrigin1))))); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 264 | EXPECT_EQ(1, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 265 | 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] | c0d50816 | 2013-12-04 22:49:00 | [diff] [blame] | 270 | 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] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 278 | |
[email protected] | 654512b | 2010-09-01 02:09:42 | [diff] [blame] | 279 | // Delete databases modified since yesterday. db2 is whitelisted. |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 280 | base::Time yesterday = base::Time::Now(); |
| 281 | yesterday -= base::TimeDelta::FromDays(1); |
[email protected] | 654512b | 2010-09-01 02:09:42 | [diff] [blame] | 282 | result = tracker->DeleteDataModifiedSince( |
[email protected] | 00bbe166 | 2011-12-22 02:25:21 | [diff] [blame] | 283 | yesterday, callback.callback()); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 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); |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 291 | EXPECT_FALSE(base::PathExists( |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 292 | tracker->DatabaseDirectory().AppendASCII(kOrigin1))); |
[email protected] | 654512b | 2010-09-01 02:09:42 | [diff] [blame] | 293 | EXPECT_TRUE( |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 294 | base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2))); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 295 | EXPECT_TRUE( |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 296 | base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3))); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 297 | |
| 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] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 304 | base::ScopedTempDir temp_dir; |
[email protected] | 8e43e07 | 2010-07-28 21:30:34 | [diff] [blame] | 305 | ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 306 | scoped_refptr<MockSpecialStoragePolicy> special_storage_policy = |
| 307 | new MockSpecialStoragePolicy; |
[email protected] | d024044 | 2011-08-17 09:23:00 | [diff] [blame] | 308 | special_storage_policy->AddProtected(GURL(kOrigin2Url)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 309 | scoped_refptr<DatabaseTracker> tracker( |
[email protected] | ff875be5 | 2013-06-02 23:47:38 | [diff] [blame] | 310 | new DatabaseTracker(temp_dir.path(), |
| 311 | incognito_mode, |
| 312 | special_storage_policy.get(), |
| 313 | NULL, |
| 314 | NULL)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 315 | |
| 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] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 324 | const std::string kOrigin1 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 325 | storage::GetIdentifierFromOrigin(GURL(kOrigin1Url)); |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 326 | const std::string kOrigin2 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 327 | storage::GetIdentifierFromOrigin(GURL(kOrigin2Url)); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 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"); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 332 | |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 333 | // Get the info for kOrigin1 and kOrigin2 |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 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); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 340 | |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 341 | |
| 342 | tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 343 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 344 | EXPECT_EQ(0, database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 345 | tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 346 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 347 | EXPECT_EQ(0, database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 348 | tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 349 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 350 | EXPECT_EQ(0, database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 351 | |
| 352 | // Write some data to each file and check that the listeners are |
| 353 | // called with the appropriate values. |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 354 | EXPECT_TRUE(base::CreateDirectory( |
[email protected] | e434fe7 | 2013-08-25 16:18:40 | [diff] [blame] | 355 | tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe( |
| 356 | tracker->GetOriginDirectory(kOrigin1))))); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 357 | EXPECT_TRUE(base::CreateDirectory( |
[email protected] | e434fe7 | 2013-08-25 16:18:40 | [diff] [blame] | 358 | tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe( |
| 359 | tracker->GetOriginDirectory(kOrigin2))))); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 360 | EXPECT_EQ(1, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 361 | tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1)); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 362 | EXPECT_EQ(2, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 363 | tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2)); |
[email protected] | e5c2a22e | 2014-03-06 20:42:30 | [diff] [blame] | 364 | EXPECT_EQ(4, base::WriteFile( |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 365 | tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa", 4)); |
| 366 | tracker->DatabaseModified(kOrigin1, kDB1); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 367 | CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1); |
| 368 | CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 369 | tracker->DatabaseModified(kOrigin2, kDB2); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 370 | CheckNotificationReceived(&observer1, kOrigin2, kDB2, 2); |
| 371 | CheckNotificationReceived(&observer2, kOrigin2, kDB2, 2); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 372 | tracker->DatabaseModified(kOrigin1, kDB3); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 373 | CheckNotificationReceived(&observer1, kOrigin1, kDB3, 4); |
| 374 | CheckNotificationReceived(&observer2, kOrigin1, kDB3, 4); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 375 | |
| 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] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 383 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 384 | EXPECT_EQ(1, database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 385 | tracker->DatabaseClosed(kOrigin1, kDB1); |
| 386 | |
| 387 | // Remove an observer; this should clear all caches. |
| 388 | tracker->RemoveObserver(&observer2); |
| 389 | |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 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, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 394 | &database_size); |
| 395 | EXPECT_EQ(1, database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 396 | 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] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 403 | &database_size); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 404 | EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3)); |
| 405 | origin1_info = tracker->GetCachedOriginInfo(kOrigin1); |
| 406 | EXPECT_TRUE(origin1_info); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 407 | EXPECT_EQ(4, origin1_info->GetDatabaseSize(kDB3)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 408 | 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] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 414 | EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 415 | 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] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 421 | EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier()); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 422 | EXPECT_EQ(1, origins_info[0].TotalSize()); |
| 423 | EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 424 | EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3)); |
| 425 | |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 426 | EXPECT_EQ(kOrigin2, origins_info[1].GetOriginIdentifier()); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 427 | EXPECT_EQ(2, origins_info[1].TotalSize()); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 428 | |
| 429 | // Trying to delete an origin with databases in use should fail |
| 430 | tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 431 | &database_size); |
[email protected] | 800ad56 | 2011-07-08 08:00:50 | [diff] [blame] | 432 | EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 433 | origin1_info = tracker->GetCachedOriginInfo(kOrigin1); |
| 434 | EXPECT_TRUE(origin1_info); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 435 | EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 436 | tracker->DatabaseClosed(kOrigin1, kDB1); |
| 437 | |
| 438 | // Delete an origin that doesn't have any database in use |
[email protected] | 800ad56 | 2011-07-08 08:00:50 | [diff] [blame] | 439 | EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false)); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 440 | origins_info.clear(); |
| 441 | EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info)); |
| 442 | EXPECT_EQ(size_t(1), origins_info.size()); |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 443 | EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier()); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 444 | |
| 445 | origin1_info = tracker->GetCachedOriginInfo(kOrigin1); |
| 446 | EXPECT_TRUE(origin1_info); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 447 | EXPECT_EQ(0, origin1_info->TotalSize()); |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 448 | } |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 449 | |
| 450 | static void DatabaseTrackerQuotaIntegration() { |
| 451 | const GURL kOrigin(kOrigin1Url); |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 452 | const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 453 | const base::string16 kName = ASCIIToUTF16("name"); |
| 454 | const base::string16 kDescription = ASCIIToUTF16("description"); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 455 | |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 456 | base::ScopedTempDir temp_dir; |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 457 | 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] | ff875be5 | 2013-06-02 23:47:38 | [diff] [blame] | 463 | new DatabaseTracker(temp_dir.path(), |
| 464 | false /* incognito */, |
| 465 | NULL, |
| 466 | test_quota_proxy.get(), |
| 467 | NULL)); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 468 | 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] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 474 | tracker->DatabaseOpened(kOriginId, kName, kDescription, 0, |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 475 | &database_size); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 476 | EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin)); |
| 477 | test_quota_proxy->reset(); |
| 478 | |
[email protected] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 479 | base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName)); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 480 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 481 | 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] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 492 | EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin)); |
[email protected] | 00bbe166 | 2011-12-22 02:25:21 | [diff] [blame] | 493 | EXPECT_EQ(net::OK, tracker->DeleteDatabase( |
| 494 | kOriginId, kName, net::CompletionCallback())); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 495 | EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100)); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 496 | test_quota_proxy->reset(); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 497 | |
| 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] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 503 | &database_size); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 504 | EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin)); |
| 505 | test_quota_proxy->reset(); |
| 506 | |
| 507 | db_file = tracker->GetFullDBFilePath(kOriginId, kName); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 508 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 509 | 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] | 00bbe166 | 2011-12-22 02:25:21 | [diff] [blame] | 515 | tracker->DeleteDatabase(kOriginId, kName, |
| 516 | net::CompletionCallback())); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 517 | EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100)); |
| 518 | |
| 519 | tracker->DatabaseClosed(kOriginId, kName); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 520 | EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin)); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 521 | EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100)); |
[email protected] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 522 | test_quota_proxy->reset(); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 523 | |
| 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] | 7c5f2ec | 2011-05-26 19:15:26 | [diff] [blame] | 530 | &database_size); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 531 | EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin)); |
| 532 | test_quota_proxy->reset(); |
| 533 | db_file = tracker->GetFullDBFilePath(kOriginId, kName); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 534 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 535 | 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] | 800ad56 | 2011-07-08 08:00:50 | [diff] [blame] | 546 | |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 547 | static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() { |
| 548 | int64 database_size = 0; |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 549 | const std::string kOrigin1 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 550 | storage::GetIdentifierFromOrigin(GURL(kOrigin1Url)); |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 551 | const std::string kOrigin2 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 552 | storage::GetIdentifierFromOrigin(GURL(kOrigin2Url)); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 553 | const base::string16 kDB1 = ASCIIToUTF16("db1"); |
| 554 | const base::string16 kDB2 = ASCIIToUTF16("db2"); |
| 555 | const base::string16 kDescription = ASCIIToUTF16("database_description"); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 556 | |
| 557 | // Initialize the tracker database. |
[email protected] | 4cc586b | 2013-05-07 12:43:32 | [diff] [blame] | 558 | base::MessageLoop message_loop; |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 559 | base::ScopedTempDir temp_dir; |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 560 | ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
[email protected] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 561 | base::FilePath origin1_db_dir; |
| 562 | base::FilePath origin2_db_dir; |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 563 | { |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 564 | scoped_refptr<MockSpecialStoragePolicy> special_storage_policy = |
| 565 | new MockSpecialStoragePolicy; |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 566 | special_storage_policy->AddSessionOnly(GURL(kOrigin2Url)); |
| 567 | scoped_refptr<DatabaseTracker> tracker( |
[email protected] | ff875be5 | 2013-06-02 23:47:38 | [diff] [blame] | 568 | new DatabaseTracker(temp_dir.path(), |
| 569 | false, |
| 570 | special_storage_policy.get(), |
| 571 | NULL, |
[email protected] | cadac62 | 2013-06-11 16:46:36 | [diff] [blame] | 572 | base::MessageLoopProxy::current().get())); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 573 | |
| 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] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 583 | base::FilePath db_file; |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 584 | db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 585 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 586 | EXPECT_TRUE(EnsureFileOfSize(db_file, 1)); |
| 587 | |
| 588 | db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 589 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 590 | 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] | 142dd75 | 2012-02-27 22:27:41 | [diff] [blame] | 608 | new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL)); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 609 | |
| 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] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 616 | EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier()); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 617 | EXPECT_TRUE( |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 618 | base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1))); |
[email protected] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 619 | EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2)); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 620 | |
| 621 | // The origin directory of kOrigin1 remains, but the origin directory of |
| 622 | // kOrigin2 is deleted. |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 623 | EXPECT_TRUE(base::PathExists(origin1_db_dir)); |
| 624 | EXPECT_FALSE(base::PathExists(origin2_db_dir)); |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 625 | } |
| 626 | |
[email protected] | bf510ed | 2012-06-05 08:31:43 | [diff] [blame] | 627 | static void DatabaseTrackerSetForceKeepSessionState() { |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 628 | int64 database_size = 0; |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 629 | const std::string kOrigin1 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 630 | storage::GetIdentifierFromOrigin(GURL(kOrigin1Url)); |
[email protected] | 5e30159 | 2013-06-18 06:36:05 | [diff] [blame] | 631 | const std::string kOrigin2 = |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 632 | storage::GetIdentifierFromOrigin(GURL(kOrigin2Url)); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 633 | const base::string16 kDB1 = ASCIIToUTF16("db1"); |
| 634 | const base::string16 kDB2 = ASCIIToUTF16("db2"); |
| 635 | const base::string16 kDescription = ASCIIToUTF16("database_description"); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 636 | |
| 637 | // Initialize the tracker database. |
[email protected] | 4cc586b | 2013-05-07 12:43:32 | [diff] [blame] | 638 | base::MessageLoop message_loop; |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 639 | base::ScopedTempDir temp_dir; |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 640 | ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
[email protected] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 641 | base::FilePath origin1_db_dir; |
| 642 | base::FilePath origin2_db_dir; |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 643 | { |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 644 | scoped_refptr<MockSpecialStoragePolicy> special_storage_policy = |
| 645 | new MockSpecialStoragePolicy; |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 646 | special_storage_policy->AddSessionOnly(GURL(kOrigin2Url)); |
| 647 | scoped_refptr<DatabaseTracker> tracker( |
[email protected] | ff875be5 | 2013-06-02 23:47:38 | [diff] [blame] | 648 | new DatabaseTracker(temp_dir.path(), |
| 649 | false, |
| 650 | special_storage_policy.get(), |
| 651 | NULL, |
[email protected] | cadac62 | 2013-06-11 16:46:36 | [diff] [blame] | 652 | base::MessageLoopProxy::current().get())); |
[email protected] | bf510ed | 2012-06-05 08:31:43 | [diff] [blame] | 653 | tracker->SetForceKeepSessionState(); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 654 | |
| 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] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 664 | base::FilePath db_file; |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 665 | db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 666 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 667 | EXPECT_TRUE(EnsureFileOfSize(db_file, 1)); |
| 668 | |
| 669 | db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 670 | EXPECT_TRUE(base::CreateDirectory(db_file.DirName())); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 671 | 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] | 142dd75 | 2012-02-27 22:27:41 | [diff] [blame] | 689 | new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL)); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 690 | |
| 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] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 697 | base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1))); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 698 | EXPECT_TRUE( |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 699 | base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2))); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 700 | |
[email protected] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 701 | EXPECT_TRUE(base::PathExists(origin1_db_dir)); |
| 702 | EXPECT_TRUE(base::PathExists(origin2_db_dir)); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 703 | } |
| 704 | |
[email protected] | e5a3cdc | 2011-08-26 19:49:53 | [diff] [blame] | 705 | static void EmptyDatabaseNameIsValid() { |
| 706 | const GURL kOrigin(kOrigin1Url); |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 707 | const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 708 | const base::string16 kEmptyName; |
| 709 | const base::string16 kDescription(ASCIIToUTF16("description")); |
| 710 | const base::string16 kChangedDescription( |
| 711 | ASCIIToUTF16("changed_description")); |
[email protected] | e5a3cdc | 2011-08-26 19:49:53 | [diff] [blame] | 712 | |
| 713 | // Initialize a tracker database, no need to put it on disk. |
| 714 | const bool kUseInMemoryTrackerDatabase = true; |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 715 | base::ScopedTempDir temp_dir; |
[email protected] | e5a3cdc | 2011-08-26 19:49:53 | [diff] [blame] | 716 | ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| 717 | scoped_refptr<DatabaseTracker> tracker( |
| 718 | new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase, |
[email protected] | 142dd75 | 2012-02-27 22:27:41 | [diff] [blame] | 719 | NULL, NULL, NULL)); |
[email protected] | e5a3cdc | 2011-08-26 19:49:53 | [diff] [blame] | 720 | |
| 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] | 00bbe166 | 2011-12-22 02:25:21 | [diff] [blame] | 746 | EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kEmptyName, |
| 747 | net::CompletionCallback())); |
[email protected] | e5a3cdc | 2011-08-26 19:49:53 | [diff] [blame] | 748 | infos.clear(); |
| 749 | EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos)); |
| 750 | EXPECT_TRUE(infos.empty()); |
| 751 | } |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 752 | |
| 753 | static void HandleSqliteError() { |
| 754 | const GURL kOrigin(kOrigin1Url); |
[email protected] | cd501a7 | 2014-08-22 19:58:31 | [diff] [blame] | 755 | const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin); |
[email protected] | 8275835 | 2013-03-29 19:21:31 | [diff] [blame] | 756 | const base::string16 kName(ASCIIToUTF16("name")); |
| 757 | const base::string16 kDescription(ASCIIToUTF16("description")); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 758 | |
| 759 | // Initialize a tracker database, no need to put it on disk. |
| 760 | const bool kUseInMemoryTrackerDatabase = true; |
[email protected] | ea1a3f6 | 2012-11-16 20:34:23 | [diff] [blame] | 761 | base::ScopedTempDir temp_dir; |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 762 | ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| 763 | scoped_refptr<DatabaseTracker> tracker( |
| 764 | new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase, |
[email protected] | 142dd75 | 2012-02-27 22:27:41 | [diff] [blame] | 765 | NULL, NULL, NULL)); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 766 | |
| 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] | a3ef483 | 2013-02-02 05:12:33 | [diff] [blame] | 782 | base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 783 | EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty()); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 784 | EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName())); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 785 | 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] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 797 | EXPECT_TRUE(base::PathExists(spoof_db_file)); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 798 | |
| 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] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 802 | EXPECT_FALSE(base::PathExists(spoof_db_file)); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 803 | 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] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 809 | &database_size); |
| 810 | base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId, |
| 811 | kName); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 812 | EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty()); |
| 813 | EXPECT_NE(spoof_db_file, spoof_db_file2); |
[email protected] | 426d1c9 | 2013-12-03 20:08:54 | [diff] [blame] | 814 | EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName())); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 815 | 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] | 756748414 | 2013-07-11 17:36:07 | [diff] [blame] | 823 | EXPECT_FALSE(base::PathExists(spoof_db_file2)); |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 824 | |
| 825 | tracker->RemoveObserver(&observer); |
| 826 | } |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 827 | }; |
| 828 | |
[email protected] | ec3d145 | 2010-02-18 10:02:26 | [diff] [blame] | 829 | TEST(DatabaseTrackerTest, DeleteOpenDatabase) { |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 830 | DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(false); |
| 831 | } |
[email protected] | ec3d145 | 2010-02-18 10:02:26 | [diff] [blame] | 832 | |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 833 | TEST(DatabaseTrackerTest, DeleteOpenDatabaseIncognitoMode) { |
| 834 | DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(true); |
[email protected] | ec3d145 | 2010-02-18 10:02:26 | [diff] [blame] | 835 | } |
| 836 | |
[email protected] | 49cd5da | 2010-04-02 00:29:51 | [diff] [blame] | 837 | TEST(DatabaseTrackerTest, DatabaseTracker) { |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 838 | DatabaseTracker_TestHelper_Test::TestDatabaseTracker(false); |
[email protected] | 615dedfc | 2009-11-02 21:41:56 | [diff] [blame] | 839 | } |
| 840 | |
[email protected] | fe615f3 | 2010-06-13 09:08:41 | [diff] [blame] | 841 | TEST(DatabaseTrackerTest, DatabaseTrackerIncognitoMode) { |
| 842 | DatabaseTracker_TestHelper_Test::TestDatabaseTracker(true); |
[email protected] | 49cd5da | 2010-04-02 00:29:51 | [diff] [blame] | 843 | } |
| 844 | |
[email protected] | eea70ad | 2011-05-15 00:24:13 | [diff] [blame] | 845 | TEST(DatabaseTrackerTest, DatabaseTrackerQuotaIntegration) { |
| 846 | // There is no difference in behavior between incognito and not. |
| 847 | DatabaseTracker_TestHelper_Test::DatabaseTrackerQuotaIntegration(); |
| 848 | } |
| 849 | |
[email protected] | f5d75f7 | 2011-09-08 11:31:40 | [diff] [blame] | 850 | TEST(DatabaseTrackerTest, DatabaseTrackerClearSessionOnlyDatabasesOnExit) { |
| 851 | // Only works for regular mode. |
| 852 | DatabaseTracker_TestHelper_Test:: |
| 853 | DatabaseTrackerClearSessionOnlyDatabasesOnExit(); |
| 854 | } |
| 855 | |
[email protected] | bf510ed | 2012-06-05 08:31:43 | [diff] [blame] | 856 | TEST(DatabaseTrackerTest, DatabaseTrackerSetForceKeepSessionState) { |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 857 | // Only works for regular mode. |
[email protected] | bf510ed | 2012-06-05 08:31:43 | [diff] [blame] | 858 | DatabaseTracker_TestHelper_Test::DatabaseTrackerSetForceKeepSessionState(); |
[email protected] | e900577 | 2011-12-08 10:44:03 | [diff] [blame] | 859 | } |
| 860 | |
[email protected] | e5a3cdc | 2011-08-26 19:49:53 | [diff] [blame] | 861 | TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) { |
| 862 | DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid(); |
| 863 | } |
| 864 | |
[email protected] | 1f1db25 | 2012-02-18 01:04:14 | [diff] [blame] | 865 | TEST(DatabaseTrackerTest, HandleSqliteError) { |
| 866 | DatabaseTracker_TestHelper_Test::HandleSqliteError(); |
| 867 | } |
| 868 | |
[email protected] | 523e5c59 | 2014-04-30 21:46:25 | [diff] [blame] | 869 | } // namespace content |