OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "webkit/browser/fileapi/quota/quota_backend_impl.h" | 5 #include "storage/browser/fileapi/quota/quota_backend_impl.h" |
6 | 6 |
7 #include <string> | 7 #include <string> |
8 | 8 |
9 #include "base/files/scoped_temp_dir.h" | 9 #include "base/files/scoped_temp_dir.h" |
10 #include "base/message_loop/message_loop.h" | 10 #include "base/message_loop/message_loop.h" |
11 #include "testing/gtest/include/gtest/gtest.h" | 11 #include "testing/gtest/include/gtest/gtest.h" |
12 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h" | 12 #include "third_party/leveldatabase/src/helpers/memenv/memenv.h" |
13 #include "third_party/leveldatabase/src/include/leveldb/env.h" | 13 #include "third_party/leveldatabase/src/include/leveldb/env.h" |
14 #include "webkit/browser/fileapi/file_system_usage_cache.h" | 14 #include "storage/browser/fileapi/file_system_usage_cache.h" |
15 #include "webkit/browser/fileapi/obfuscated_file_util.h" | 15 #include "storage/browser/fileapi/obfuscated_file_util.h" |
16 #include "webkit/browser/quota/quota_manager_proxy.h" | 16 #include "storage/browser/quota/quota_manager_proxy.h" |
17 | 17 |
18 using fileapi::FileSystemUsageCache; | 18 using storage::FileSystemUsageCache; |
19 using fileapi::ObfuscatedFileUtil; | 19 using storage::ObfuscatedFileUtil; |
20 using fileapi::QuotaBackendImpl; | 20 using storage::QuotaBackendImpl; |
21 using fileapi::SandboxFileSystemBackendDelegate; | 21 using storage::SandboxFileSystemBackendDelegate; |
22 | 22 |
23 namespace content { | 23 namespace content { |
24 | 24 |
25 namespace { | 25 namespace { |
26 | 26 |
27 const char kOrigin[] = "http://example.com"; | 27 const char kOrigin[] = "http://example.com"; |
28 | 28 |
29 bool DidReserveQuota(bool accepted, | 29 bool DidReserveQuota(bool accepted, |
30 base::File::Error* error_out, | 30 base::File::Error* error_out, |
31 int64* delta_out, | 31 int64* delta_out, |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
108 | 108 |
109 virtual void TearDown() OVERRIDE { | 109 virtual void TearDown() OVERRIDE { |
110 backend_.reset(); | 110 backend_.reset(); |
111 quota_manager_proxy_ = NULL; | 111 quota_manager_proxy_ = NULL; |
112 file_util_.reset(); | 112 file_util_.reset(); |
113 message_loop_.RunUntilIdle(); | 113 message_loop_.RunUntilIdle(); |
114 } | 114 } |
115 | 115 |
116 protected: | 116 protected: |
117 void InitializeForOriginAndType(const GURL& origin, | 117 void InitializeForOriginAndType(const GURL& origin, |
118 fileapi::FileSystemType type) { | 118 storage::FileSystemType type) { |
119 ASSERT_TRUE(file_util_->InitOriginDatabase(origin, true /* create */)); | 119 ASSERT_TRUE(file_util_->InitOriginDatabase(origin, true /* create */)); |
120 ASSERT_TRUE(file_util_->origin_database_ != NULL); | 120 ASSERT_TRUE(file_util_->origin_database_ != NULL); |
121 | 121 |
122 std::string type_string = | 122 std::string type_string = |
123 SandboxFileSystemBackendDelegate::GetTypeString(type); | 123 SandboxFileSystemBackendDelegate::GetTypeString(type); |
124 base::File::Error error = base::File::FILE_ERROR_FAILED; | 124 base::File::Error error = base::File::FILE_ERROR_FAILED; |
125 base::FilePath path = file_util_->GetDirectoryForOriginAndType( | 125 base::FilePath path = file_util_->GetDirectoryForOriginAndType( |
126 origin, type_string, true /* create */, &error); | 126 origin, type_string, true /* create */, &error); |
127 ASSERT_EQ(base::File::FILE_OK, error); | 127 ASSERT_EQ(base::File::FILE_OK, error); |
128 | 128 |
129 ASSERT_TRUE(file_system_usage_cache_.UpdateUsage( | 129 ASSERT_TRUE(file_system_usage_cache_.UpdateUsage( |
130 GetUsageCachePath(origin, type), 0)); | 130 GetUsageCachePath(origin, type), 0)); |
131 } | 131 } |
132 | 132 |
133 base::SequencedTaskRunner* file_task_runner() { | 133 base::SequencedTaskRunner* file_task_runner() { |
134 return base::MessageLoopProxy::current().get(); | 134 return base::MessageLoopProxy::current().get(); |
135 } | 135 } |
136 | 136 |
137 base::FilePath GetUsageCachePath(const GURL& origin, | 137 base::FilePath GetUsageCachePath(const GURL& origin, |
138 fileapi::FileSystemType type) { | 138 storage::FileSystemType type) { |
139 base::FilePath path; | 139 base::FilePath path; |
140 base::File::Error error = | 140 base::File::Error error = |
141 backend_->GetUsageCachePath(origin, type, &path); | 141 backend_->GetUsageCachePath(origin, type, &path); |
142 EXPECT_EQ(base::File::FILE_OK, error); | 142 EXPECT_EQ(base::File::FILE_OK, error); |
143 EXPECT_FALSE(path.empty()); | 143 EXPECT_FALSE(path.empty()); |
144 return path; | 144 return path; |
145 } | 145 } |
146 | 146 |
147 base::MessageLoop message_loop_; | 147 base::MessageLoop message_loop_; |
148 base::ScopedTempDir data_dir_; | 148 base::ScopedTempDir data_dir_; |
149 scoped_ptr<leveldb::Env> in_memory_env_; | 149 scoped_ptr<leveldb::Env> in_memory_env_; |
150 scoped_ptr<ObfuscatedFileUtil> file_util_; | 150 scoped_ptr<ObfuscatedFileUtil> file_util_; |
151 FileSystemUsageCache file_system_usage_cache_; | 151 FileSystemUsageCache file_system_usage_cache_; |
152 scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_; | 152 scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_; |
153 scoped_ptr<QuotaBackendImpl> backend_; | 153 scoped_ptr<QuotaBackendImpl> backend_; |
154 | 154 |
155 private: | 155 private: |
156 DISALLOW_COPY_AND_ASSIGN(QuotaBackendImplTest); | 156 DISALLOW_COPY_AND_ASSIGN(QuotaBackendImplTest); |
157 }; | 157 }; |
158 | 158 |
159 TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) { | 159 TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) { |
160 fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary; | 160 storage::FileSystemType type = storage::kFileSystemTypeTemporary; |
161 InitializeForOriginAndType(GURL(kOrigin), type); | 161 InitializeForOriginAndType(GURL(kOrigin), type); |
162 quota_manager_proxy_->set_quota(10000); | 162 quota_manager_proxy_->set_quota(10000); |
163 | 163 |
164 int64 delta = 0; | 164 int64 delta = 0; |
165 | 165 |
166 const int64 kDelta1 = 1000; | 166 const int64 kDelta1 = 1000; |
167 base::File::Error error = base::File::FILE_ERROR_FAILED; | 167 base::File::Error error = base::File::FILE_ERROR_FAILED; |
168 backend_->ReserveQuota(GURL(kOrigin), type, kDelta1, | 168 backend_->ReserveQuota(GURL(kOrigin), type, kDelta1, |
169 base::Bind(&DidReserveQuota, true, &error, &delta)); | 169 base::Bind(&DidReserveQuota, true, &error, &delta)); |
170 EXPECT_EQ(base::File::FILE_OK, error); | 170 EXPECT_EQ(base::File::FILE_OK, error); |
171 EXPECT_EQ(kDelta1, delta); | 171 EXPECT_EQ(kDelta1, delta); |
172 EXPECT_EQ(kDelta1, quota_manager_proxy_->usage()); | 172 EXPECT_EQ(kDelta1, quota_manager_proxy_->usage()); |
173 | 173 |
174 const int64 kDelta2 = -300; | 174 const int64 kDelta2 = -300; |
175 error = base::File::FILE_ERROR_FAILED; | 175 error = base::File::FILE_ERROR_FAILED; |
176 backend_->ReserveQuota(GURL(kOrigin), type, kDelta2, | 176 backend_->ReserveQuota(GURL(kOrigin), type, kDelta2, |
177 base::Bind(&DidReserveQuota, true, &error, &delta)); | 177 base::Bind(&DidReserveQuota, true, &error, &delta)); |
178 EXPECT_EQ(base::File::FILE_OK, error); | 178 EXPECT_EQ(base::File::FILE_OK, error); |
179 EXPECT_EQ(kDelta2, delta); | 179 EXPECT_EQ(kDelta2, delta); |
180 EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage()); | 180 EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage()); |
181 | 181 |
182 EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count()); | 182 EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count()); |
183 } | 183 } |
184 | 184 |
185 TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) { | 185 TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) { |
186 fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary; | 186 storage::FileSystemType type = storage::kFileSystemTypeTemporary; |
187 InitializeForOriginAndType(GURL(kOrigin), type); | 187 InitializeForOriginAndType(GURL(kOrigin), type); |
188 quota_manager_proxy_->set_quota(100); | 188 quota_manager_proxy_->set_quota(100); |
189 | 189 |
190 int64 delta = 0; | 190 int64 delta = 0; |
191 | 191 |
192 const int64 kDelta = 1000; | 192 const int64 kDelta = 1000; |
193 base::File::Error error = base::File::FILE_ERROR_FAILED; | 193 base::File::Error error = base::File::FILE_ERROR_FAILED; |
194 backend_->ReserveQuota(GURL(kOrigin), type, kDelta, | 194 backend_->ReserveQuota(GURL(kOrigin), type, kDelta, |
195 base::Bind(&DidReserveQuota, true, &error, &delta)); | 195 base::Bind(&DidReserveQuota, true, &error, &delta)); |
196 EXPECT_EQ(base::File::FILE_OK, error); | 196 EXPECT_EQ(base::File::FILE_OK, error); |
197 EXPECT_EQ(100, delta); | 197 EXPECT_EQ(100, delta); |
198 EXPECT_EQ(100, quota_manager_proxy_->usage()); | 198 EXPECT_EQ(100, quota_manager_proxy_->usage()); |
199 | 199 |
200 EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count()); | 200 EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count()); |
201 } | 201 } |
202 | 202 |
203 TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) { | 203 TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) { |
204 fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary; | 204 storage::FileSystemType type = storage::kFileSystemTypeTemporary; |
205 InitializeForOriginAndType(GURL(kOrigin), type); | 205 InitializeForOriginAndType(GURL(kOrigin), type); |
206 quota_manager_proxy_->set_quota(10000); | 206 quota_manager_proxy_->set_quota(10000); |
207 | 207 |
208 int64 delta = 0; | 208 int64 delta = 0; |
209 | 209 |
210 const int64 kDelta = 1000; | 210 const int64 kDelta = 1000; |
211 base::File::Error error = base::File::FILE_ERROR_FAILED; | 211 base::File::Error error = base::File::FILE_ERROR_FAILED; |
212 backend_->ReserveQuota(GURL(kOrigin), type, kDelta, | 212 backend_->ReserveQuota(GURL(kOrigin), type, kDelta, |
213 base::Bind(&DidReserveQuota, false, &error, &delta)); | 213 base::Bind(&DidReserveQuota, false, &error, &delta)); |
214 EXPECT_EQ(base::File::FILE_OK, error); | 214 EXPECT_EQ(base::File::FILE_OK, error); |
215 EXPECT_EQ(kDelta, delta); | 215 EXPECT_EQ(kDelta, delta); |
216 EXPECT_EQ(0, quota_manager_proxy_->usage()); | 216 EXPECT_EQ(0, quota_manager_proxy_->usage()); |
217 | 217 |
218 EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count()); | 218 EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count()); |
219 } | 219 } |
220 | 220 |
221 TEST_F(QuotaBackendImplTest, ReleaseReservedQuota) { | 221 TEST_F(QuotaBackendImplTest, ReleaseReservedQuota) { |
222 fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary; | 222 storage::FileSystemType type = storage::kFileSystemTypeTemporary; |
223 InitializeForOriginAndType(GURL(kOrigin), type); | 223 InitializeForOriginAndType(GURL(kOrigin), type); |
224 const int64 kInitialUsage = 2000; | 224 const int64 kInitialUsage = 2000; |
225 quota_manager_proxy_->set_usage(kInitialUsage); | 225 quota_manager_proxy_->set_usage(kInitialUsage); |
226 quota_manager_proxy_->set_quota(10000); | 226 quota_manager_proxy_->set_quota(10000); |
227 | 227 |
228 const int64 kSize = 1000; | 228 const int64 kSize = 1000; |
229 backend_->ReleaseReservedQuota(GURL(kOrigin), type, kSize); | 229 backend_->ReleaseReservedQuota(GURL(kOrigin), type, kSize); |
230 EXPECT_EQ(kInitialUsage - kSize, quota_manager_proxy_->usage()); | 230 EXPECT_EQ(kInitialUsage - kSize, quota_manager_proxy_->usage()); |
231 | 231 |
232 EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count()); | 232 EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count()); |
233 } | 233 } |
234 | 234 |
235 TEST_F(QuotaBackendImplTest, CommitQuotaUsage) { | 235 TEST_F(QuotaBackendImplTest, CommitQuotaUsage) { |
236 fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary; | 236 storage::FileSystemType type = storage::kFileSystemTypeTemporary; |
237 InitializeForOriginAndType(GURL(kOrigin), type); | 237 InitializeForOriginAndType(GURL(kOrigin), type); |
238 quota_manager_proxy_->set_quota(10000); | 238 quota_manager_proxy_->set_quota(10000); |
239 base::FilePath path = GetUsageCachePath(GURL(kOrigin), type); | 239 base::FilePath path = GetUsageCachePath(GURL(kOrigin), type); |
240 | 240 |
241 const int64 kDelta1 = 1000; | 241 const int64 kDelta1 = 1000; |
242 backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta1); | 242 backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta1); |
243 EXPECT_EQ(kDelta1, quota_manager_proxy_->usage()); | 243 EXPECT_EQ(kDelta1, quota_manager_proxy_->usage()); |
244 int64 usage = 0; | 244 int64 usage = 0; |
245 EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage)); | 245 EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage)); |
246 EXPECT_EQ(kDelta1, usage); | 246 EXPECT_EQ(kDelta1, usage); |
247 | 247 |
248 const int64 kDelta2 = -300; | 248 const int64 kDelta2 = -300; |
249 backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta2); | 249 backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta2); |
250 EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage()); | 250 EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage()); |
251 usage = 0; | 251 usage = 0; |
252 EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage)); | 252 EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage)); |
253 EXPECT_EQ(kDelta1 + kDelta2, usage); | 253 EXPECT_EQ(kDelta1 + kDelta2, usage); |
254 | 254 |
255 EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count()); | 255 EXPECT_EQ(2, quota_manager_proxy_->storage_modified_count()); |
256 } | 256 } |
257 | 257 |
258 TEST_F(QuotaBackendImplTest, DirtyCount) { | 258 TEST_F(QuotaBackendImplTest, DirtyCount) { |
259 fileapi::FileSystemType type = fileapi::kFileSystemTypeTemporary; | 259 storage::FileSystemType type = storage::kFileSystemTypeTemporary; |
260 InitializeForOriginAndType(GURL(kOrigin), type); | 260 InitializeForOriginAndType(GURL(kOrigin), type); |
261 base::FilePath path = GetUsageCachePath(GURL(kOrigin), type); | 261 base::FilePath path = GetUsageCachePath(GURL(kOrigin), type); |
262 | 262 |
263 backend_->IncrementDirtyCount(GURL(kOrigin), type); | 263 backend_->IncrementDirtyCount(GURL(kOrigin), type); |
264 uint32 dirty = 0; | 264 uint32 dirty = 0; |
265 ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty)); | 265 ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty)); |
266 EXPECT_EQ(1u, dirty); | 266 EXPECT_EQ(1u, dirty); |
267 | 267 |
268 backend_->DecrementDirtyCount(GURL(kOrigin), type); | 268 backend_->DecrementDirtyCount(GURL(kOrigin), type); |
269 ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty)); | 269 ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty)); |
270 EXPECT_EQ(0u, dirty); | 270 EXPECT_EQ(0u, dirty); |
271 } | 271 } |
272 | 272 |
273 } // namespace content | 273 } // namespace content |
OLD | NEW |