Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(178)

Side by Side Diff: content/browser/quota/quota_backend_impl_unittest.cc

Issue 442383002: Move storage-related files from webkit/ to new top-level directory storage/ (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: . Created 6 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
OLDNEW
« no previous file with comments | « content/browser/quota/mock_quota_manager_proxy.h ('k') | content/browser/quota/quota_database_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698