OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 <string> | 5 #include <string> |
6 #include <vector> | 6 #include <vector> |
7 | 7 |
8 #include "base/basictypes.h" | 8 #include "base/basictypes.h" |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
(...skipping 25 matching lines...) Expand all Loading... |
36 | 36 |
37 const GURL kOrigin("http://example.com"); | 37 const GURL kOrigin("http://example.com"); |
38 const fileapi::FileSystemType kFileSystemType = fileapi::kFileSystemTypeTest; | 38 const fileapi::FileSystemType kFileSystemType = fileapi::kFileSystemTypeTest; |
39 | 39 |
40 const char kData[] = "The quick brown fox jumps over the lazy dog.\n"; | 40 const char kData[] = "The quick brown fox jumps over the lazy dog.\n"; |
41 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1; | 41 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1; |
42 | 42 |
43 class Result { | 43 class Result { |
44 public: | 44 public: |
45 Result() | 45 Result() |
46 : status_(base::PLATFORM_FILE_OK), | 46 : status_(base::File::FILE_OK), |
47 bytes_written_(0), | 47 bytes_written_(0), |
48 write_status_(FileWriterDelegate::SUCCESS_IO_PENDING) {} | 48 write_status_(FileWriterDelegate::SUCCESS_IO_PENDING) {} |
49 | 49 |
50 base::PlatformFileError status() const { return status_; } | 50 base::File::Error status() const { return status_; } |
51 int64 bytes_written() const { return bytes_written_; } | 51 int64 bytes_written() const { return bytes_written_; } |
52 FileWriterDelegate::WriteProgressStatus write_status() const { | 52 FileWriterDelegate::WriteProgressStatus write_status() const { |
53 return write_status_; | 53 return write_status_; |
54 } | 54 } |
55 | 55 |
56 void DidWrite(base::PlatformFileError status, int64 bytes, | 56 void DidWrite(base::File::Error status, int64 bytes, |
57 FileWriterDelegate::WriteProgressStatus write_status) { | 57 FileWriterDelegate::WriteProgressStatus write_status) { |
58 write_status_ = write_status; | 58 write_status_ = write_status; |
59 if (status == base::PLATFORM_FILE_OK) { | 59 if (status == base::File::FILE_OK) { |
60 bytes_written_ += bytes; | 60 bytes_written_ += bytes; |
61 if (write_status_ != FileWriterDelegate::SUCCESS_IO_PENDING) | 61 if (write_status_ != FileWriterDelegate::SUCCESS_IO_PENDING) |
62 base::MessageLoop::current()->Quit(); | 62 base::MessageLoop::current()->Quit(); |
63 } else { | 63 } else { |
64 EXPECT_EQ(base::PLATFORM_FILE_OK, status_); | 64 EXPECT_EQ(base::File::FILE_OK, status_); |
65 status_ = status; | 65 status_ = status; |
66 base::MessageLoop::current()->Quit(); | 66 base::MessageLoop::current()->Quit(); |
67 } | 67 } |
68 } | 68 } |
69 | 69 |
70 private: | 70 private: |
71 // For post-operation status. | 71 // For post-operation status. |
72 base::PlatformFileError status_; | 72 base::File::Error status_; |
73 int64 bytes_written_; | 73 int64 bytes_written_; |
74 FileWriterDelegate::WriteProgressStatus write_status_; | 74 FileWriterDelegate::WriteProgressStatus write_status_; |
75 }; | 75 }; |
76 | 76 |
77 } // namespace (anonymous) | 77 } // namespace (anonymous) |
78 | 78 |
79 class FileWriterDelegateTest : public PlatformTest { | 79 class FileWriterDelegateTest : public PlatformTest { |
80 public: | 80 public: |
81 FileWriterDelegateTest() {} | 81 FileWriterDelegateTest() {} |
82 | 82 |
83 protected: | 83 protected: |
84 virtual void SetUp() OVERRIDE; | 84 virtual void SetUp() OVERRIDE; |
85 virtual void TearDown() OVERRIDE; | 85 virtual void TearDown() OVERRIDE; |
86 | 86 |
87 int64 usage() { | 87 int64 usage() { |
88 return file_system_context_->GetQuotaUtil(kFileSystemType) | 88 return file_system_context_->GetQuotaUtil(kFileSystemType) |
89 ->GetOriginUsageOnFileTaskRunner( | 89 ->GetOriginUsageOnFileTaskRunner( |
90 file_system_context_.get(), kOrigin, kFileSystemType); | 90 file_system_context_.get(), kOrigin, kFileSystemType); |
91 } | 91 } |
92 | 92 |
93 int64 GetFileSizeOnDisk(const char* test_file_path) { | 93 int64 GetFileSizeOnDisk(const char* test_file_path) { |
94 // There might be in-flight flush/write. | 94 // There might be in-flight flush/write. |
95 base::MessageLoop::current()->PostTask( | 95 base::MessageLoop::current()->PostTask( |
96 FROM_HERE, base::Bind(&base::DoNothing)); | 96 FROM_HERE, base::Bind(&base::DoNothing)); |
97 base::RunLoop().RunUntilIdle(); | 97 base::RunLoop().RunUntilIdle(); |
98 | 98 |
99 FileSystemURL url = GetFileSystemURL(test_file_path); | 99 FileSystemURL url = GetFileSystemURL(test_file_path); |
100 base::PlatformFileInfo file_info; | 100 base::File::Info file_info; |
101 EXPECT_EQ(base::PLATFORM_FILE_OK, | 101 EXPECT_EQ(base::File::FILE_OK, |
102 AsyncFileTestHelper::GetMetadata( | 102 AsyncFileTestHelper::GetMetadata( |
103 file_system_context_, url, &file_info)); | 103 file_system_context_, url, &file_info)); |
104 return file_info.size; | 104 return file_info.size; |
105 } | 105 } |
106 | 106 |
107 FileSystemURL GetFileSystemURL(const char* file_name) const { | 107 FileSystemURL GetFileSystemURL(const char* file_name) const { |
108 return file_system_context_->CreateCrackedFileSystemURL( | 108 return file_system_context_->CreateCrackedFileSystemURL( |
109 kOrigin, kFileSystemType, base::FilePath().FromUTF8Unsafe(file_name)); | 109 kOrigin, kFileSystemType, base::FilePath().FromUTF8Unsafe(file_name)); |
110 } | 110 } |
111 | 111 |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
216 const std::string& scheme) { | 216 const std::string& scheme) { |
217 return new FileWriterDelegateTestJob( | 217 return new FileWriterDelegateTestJob( |
218 request, network_delegate, FileWriterDelegateTest::content_); | 218 request, network_delegate, FileWriterDelegateTest::content_); |
219 } | 219 } |
220 | 220 |
221 void FileWriterDelegateTest::SetUp() { | 221 void FileWriterDelegateTest::SetUp() { |
222 ASSERT_TRUE(dir_.CreateUniqueTempDir()); | 222 ASSERT_TRUE(dir_.CreateUniqueTempDir()); |
223 | 223 |
224 file_system_context_ = CreateFileSystemContextForTesting( | 224 file_system_context_ = CreateFileSystemContextForTesting( |
225 NULL, dir_.path()); | 225 NULL, dir_.path()); |
226 ASSERT_EQ(base::PLATFORM_FILE_OK, | 226 ASSERT_EQ(base::File::FILE_OK, |
227 AsyncFileTestHelper::CreateFile( | 227 AsyncFileTestHelper::CreateFile( |
228 file_system_context_, GetFileSystemURL("test"))); | 228 file_system_context_, GetFileSystemURL("test"))); |
229 net::URLRequest::Deprecated::RegisterProtocolFactory("blob", &Factory); | 229 net::URLRequest::Deprecated::RegisterProtocolFactory("blob", &Factory); |
230 } | 230 } |
231 | 231 |
232 void FileWriterDelegateTest::TearDown() { | 232 void FileWriterDelegateTest::TearDown() { |
233 net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL); | 233 net::URLRequest::Deprecated::RegisterProtocolFactory("blob", NULL); |
234 file_system_context_ = NULL; | 234 file_system_context_ = NULL; |
235 base::RunLoop().RunUntilIdle(); | 235 base::RunLoop().RunUntilIdle(); |
236 } | 236 } |
237 | 237 |
238 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) { | 238 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) { |
239 const GURL kBlobURL("blob:nolimit"); | 239 const GURL kBlobURL("blob:nolimit"); |
240 content_ = kData; | 240 content_ = kData; |
241 | 241 |
242 PrepareForWrite("test", kBlobURL, 0, kint64max); | 242 PrepareForWrite("test", kBlobURL, 0, kint64max); |
243 | 243 |
244 Result result; | 244 Result result; |
245 ASSERT_EQ(0, usage()); | 245 ASSERT_EQ(0, usage()); |
246 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 246 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
247 base::MessageLoop::current()->Run(); | 247 base::MessageLoop::current()->Run(); |
248 | 248 |
249 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 249 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
250 file_writer_delegate_.reset(); | 250 file_writer_delegate_.reset(); |
251 | 251 |
252 ASSERT_EQ(kDataSize, usage()); | 252 ASSERT_EQ(kDataSize, usage()); |
253 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 253 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
254 EXPECT_EQ(kDataSize, result.bytes_written()); | 254 EXPECT_EQ(kDataSize, result.bytes_written()); |
255 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 255 EXPECT_EQ(base::File::FILE_OK, result.status()); |
256 } | 256 } |
257 | 257 |
258 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) { | 258 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) { |
259 const GURL kBlobURL("blob:just"); | 259 const GURL kBlobURL("blob:just"); |
260 content_ = kData; | 260 content_ = kData; |
261 const int64 kAllowedGrowth = kDataSize; | 261 const int64 kAllowedGrowth = kDataSize; |
262 PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth); | 262 PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth); |
263 | 263 |
264 Result result; | 264 Result result; |
265 ASSERT_EQ(0, usage()); | 265 ASSERT_EQ(0, usage()); |
266 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 266 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
267 base::MessageLoop::current()->Run(); | 267 base::MessageLoop::current()->Run(); |
268 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 268 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
269 file_writer_delegate_.reset(); | 269 file_writer_delegate_.reset(); |
270 | 270 |
271 ASSERT_EQ(kAllowedGrowth, usage()); | 271 ASSERT_EQ(kAllowedGrowth, usage()); |
272 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 272 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
273 | 273 |
274 EXPECT_EQ(kAllowedGrowth, result.bytes_written()); | 274 EXPECT_EQ(kAllowedGrowth, result.bytes_written()); |
275 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 275 EXPECT_EQ(base::File::FILE_OK, result.status()); |
276 } | 276 } |
277 | 277 |
278 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) { | 278 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) { |
279 const GURL kBlobURL("blob:failure"); | 279 const GURL kBlobURL("blob:failure"); |
280 content_ = kData; | 280 content_ = kData; |
281 const int64 kAllowedGrowth = kDataSize - 1; | 281 const int64 kAllowedGrowth = kDataSize - 1; |
282 PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth); | 282 PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth); |
283 | 283 |
284 Result result; | 284 Result result; |
285 ASSERT_EQ(0, usage()); | 285 ASSERT_EQ(0, usage()); |
286 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 286 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
287 base::MessageLoop::current()->Run(); | 287 base::MessageLoop::current()->Run(); |
288 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status()); | 288 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status()); |
289 file_writer_delegate_.reset(); | 289 file_writer_delegate_.reset(); |
290 | 290 |
291 ASSERT_EQ(kAllowedGrowth, usage()); | 291 ASSERT_EQ(kAllowedGrowth, usage()); |
292 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 292 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
293 | 293 |
294 EXPECT_EQ(kAllowedGrowth, result.bytes_written()); | 294 EXPECT_EQ(kAllowedGrowth, result.bytes_written()); |
295 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result.status()); | 295 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status()); |
296 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status()); | 296 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status()); |
297 } | 297 } |
298 | 298 |
299 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) { | 299 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) { |
300 const GURL kBlobURL("blob:zero"); | 300 const GURL kBlobURL("blob:zero"); |
301 content_ = ""; | 301 content_ = ""; |
302 int64 kAllowedGrowth = 0; | 302 int64 kAllowedGrowth = 0; |
303 PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth); | 303 PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth); |
304 | 304 |
305 Result result; | 305 Result result; |
306 ASSERT_EQ(0, usage()); | 306 ASSERT_EQ(0, usage()); |
307 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 307 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
308 base::MessageLoop::current()->Run(); | 308 base::MessageLoop::current()->Run(); |
309 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 309 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
310 file_writer_delegate_.reset(); | 310 file_writer_delegate_.reset(); |
311 | 311 |
312 ASSERT_EQ(kAllowedGrowth, usage()); | 312 ASSERT_EQ(kAllowedGrowth, usage()); |
313 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 313 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
314 | 314 |
315 EXPECT_EQ(kAllowedGrowth, result.bytes_written()); | 315 EXPECT_EQ(kAllowedGrowth, result.bytes_written()); |
316 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 316 EXPECT_EQ(base::File::FILE_OK, result.status()); |
317 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 317 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
318 } | 318 } |
319 | 319 |
320 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) { | 320 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) { |
321 scoped_ptr<FileWriterDelegate> file_writer_delegate2; | 321 scoped_ptr<FileWriterDelegate> file_writer_delegate2; |
322 scoped_ptr<net::URLRequest> request2; | 322 scoped_ptr<net::URLRequest> request2; |
323 | 323 |
324 ASSERT_EQ(base::PLATFORM_FILE_OK, | 324 ASSERT_EQ(base::File::FILE_OK, |
325 AsyncFileTestHelper::CreateFile( | 325 AsyncFileTestHelper::CreateFile( |
326 file_system_context_, GetFileSystemURL("test2"))); | 326 file_system_context_, GetFileSystemURL("test2"))); |
327 | 327 |
328 const GURL kBlobURL("blob:nolimitconcurrent"); | 328 const GURL kBlobURL("blob:nolimitconcurrent"); |
329 const GURL kBlobURL2("blob:nolimitconcurrent2"); | 329 const GURL kBlobURL2("blob:nolimitconcurrent2"); |
330 content_ = kData; | 330 content_ = kData; |
331 | 331 |
332 PrepareForWrite("test", kBlobURL, 0, kint64max); | 332 PrepareForWrite("test", kBlobURL, 0, kint64max); |
333 | 333 |
334 // Credate another FileWriterDelegate for concurrent write. | 334 // Credate another FileWriterDelegate for concurrent write. |
(...skipping 12 matching lines...) Expand all Loading... |
347 | 347 |
348 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 348 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
349 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2.write_status()); | 349 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2.write_status()); |
350 file_writer_delegate_.reset(); | 350 file_writer_delegate_.reset(); |
351 file_writer_delegate2.reset(); | 351 file_writer_delegate2.reset(); |
352 | 352 |
353 ASSERT_EQ(kDataSize * 2, usage()); | 353 ASSERT_EQ(kDataSize * 2, usage()); |
354 EXPECT_EQ(GetFileSizeOnDisk("test") + GetFileSizeOnDisk("test2"), usage()); | 354 EXPECT_EQ(GetFileSizeOnDisk("test") + GetFileSizeOnDisk("test2"), usage()); |
355 | 355 |
356 EXPECT_EQ(kDataSize, result.bytes_written()); | 356 EXPECT_EQ(kDataSize, result.bytes_written()); |
357 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 357 EXPECT_EQ(base::File::FILE_OK, result.status()); |
358 EXPECT_EQ(kDataSize, result2.bytes_written()); | 358 EXPECT_EQ(kDataSize, result2.bytes_written()); |
359 EXPECT_EQ(base::PLATFORM_FILE_OK, result2.status()); | 359 EXPECT_EQ(base::File::FILE_OK, result2.status()); |
360 } | 360 } |
361 | 361 |
362 TEST_F(FileWriterDelegateTest, WritesWithQuotaAndOffset) { | 362 TEST_F(FileWriterDelegateTest, WritesWithQuotaAndOffset) { |
363 const GURL kBlobURL("blob:failure-with-updated-quota"); | 363 const GURL kBlobURL("blob:failure-with-updated-quota"); |
364 content_ = kData; | 364 content_ = kData; |
365 | 365 |
366 // Writing kDataSize (=45) bytes data while allowed_growth is 100. | 366 // Writing kDataSize (=45) bytes data while allowed_growth is 100. |
367 int64 offset = 0; | 367 int64 offset = 0; |
368 int64 allowed_growth = 100; | 368 int64 allowed_growth = 100; |
369 ASSERT_LT(kDataSize, allowed_growth); | 369 ASSERT_LT(kDataSize, allowed_growth); |
370 PrepareForWrite("test", kBlobURL, offset, allowed_growth); | 370 PrepareForWrite("test", kBlobURL, offset, allowed_growth); |
371 | 371 |
372 { | 372 { |
373 Result result; | 373 Result result; |
374 ASSERT_EQ(0, usage()); | 374 ASSERT_EQ(0, usage()); |
375 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 375 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
376 base::MessageLoop::current()->Run(); | 376 base::MessageLoop::current()->Run(); |
377 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 377 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
378 file_writer_delegate_.reset(); | 378 file_writer_delegate_.reset(); |
379 | 379 |
380 ASSERT_EQ(kDataSize, usage()); | 380 ASSERT_EQ(kDataSize, usage()); |
381 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 381 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
382 EXPECT_EQ(kDataSize, result.bytes_written()); | 382 EXPECT_EQ(kDataSize, result.bytes_written()); |
383 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 383 EXPECT_EQ(base::File::FILE_OK, result.status()); |
384 } | 384 } |
385 | 385 |
386 // Trying to overwrite kDataSize bytes data while allowed_growth is 20. | 386 // Trying to overwrite kDataSize bytes data while allowed_growth is 20. |
387 offset = 0; | 387 offset = 0; |
388 allowed_growth = 20; | 388 allowed_growth = 20; |
389 PrepareForWrite("test", kBlobURL, offset, allowed_growth); | 389 PrepareForWrite("test", kBlobURL, offset, allowed_growth); |
390 | 390 |
391 { | 391 { |
392 Result result; | 392 Result result; |
393 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 393 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
394 base::MessageLoop::current()->Run(); | 394 base::MessageLoop::current()->Run(); |
395 EXPECT_EQ(kDataSize, usage()); | 395 EXPECT_EQ(kDataSize, usage()); |
396 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 396 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
397 EXPECT_EQ(kDataSize, result.bytes_written()); | 397 EXPECT_EQ(kDataSize, result.bytes_written()); |
398 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 398 EXPECT_EQ(base::File::FILE_OK, result.status()); |
399 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 399 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
400 } | 400 } |
401 | 401 |
402 // Trying to write kDataSize bytes data from offset 25 while | 402 // Trying to write kDataSize bytes data from offset 25 while |
403 // allowed_growth is 55. | 403 // allowed_growth is 55. |
404 offset = 25; | 404 offset = 25; |
405 allowed_growth = 55; | 405 allowed_growth = 55; |
406 PrepareForWrite("test", kBlobURL, offset, allowed_growth); | 406 PrepareForWrite("test", kBlobURL, offset, allowed_growth); |
407 | 407 |
408 { | 408 { |
409 Result result; | 409 Result result; |
410 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 410 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
411 base::MessageLoop::current()->Run(); | 411 base::MessageLoop::current()->Run(); |
412 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 412 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
413 file_writer_delegate_.reset(); | 413 file_writer_delegate_.reset(); |
414 | 414 |
415 EXPECT_EQ(offset + kDataSize, usage()); | 415 EXPECT_EQ(offset + kDataSize, usage()); |
416 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 416 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
417 EXPECT_EQ(kDataSize, result.bytes_written()); | 417 EXPECT_EQ(kDataSize, result.bytes_written()); |
418 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 418 EXPECT_EQ(base::File::FILE_OK, result.status()); |
419 } | 419 } |
420 | 420 |
421 // Trying to overwrite 45 bytes data while allowed_growth is -20. | 421 // Trying to overwrite 45 bytes data while allowed_growth is -20. |
422 offset = 0; | 422 offset = 0; |
423 allowed_growth = -20; | 423 allowed_growth = -20; |
424 PrepareForWrite("test", kBlobURL, offset, allowed_growth); | 424 PrepareForWrite("test", kBlobURL, offset, allowed_growth); |
425 int64 pre_write_usage = GetFileSizeOnDisk("test"); | 425 int64 pre_write_usage = GetFileSizeOnDisk("test"); |
426 | 426 |
427 { | 427 { |
428 Result result; | 428 Result result; |
429 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 429 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
430 base::MessageLoop::current()->Run(); | 430 base::MessageLoop::current()->Run(); |
431 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); | 431 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status()); |
432 file_writer_delegate_.reset(); | 432 file_writer_delegate_.reset(); |
433 | 433 |
434 EXPECT_EQ(pre_write_usage, usage()); | 434 EXPECT_EQ(pre_write_usage, usage()); |
435 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 435 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
436 EXPECT_EQ(kDataSize, result.bytes_written()); | 436 EXPECT_EQ(kDataSize, result.bytes_written()); |
437 EXPECT_EQ(base::PLATFORM_FILE_OK, result.status()); | 437 EXPECT_EQ(base::File::FILE_OK, result.status()); |
438 } | 438 } |
439 | 439 |
440 // Trying to overwrite 45 bytes data with offset pre_write_usage - 20, | 440 // Trying to overwrite 45 bytes data with offset pre_write_usage - 20, |
441 // while allowed_growth is 10. | 441 // while allowed_growth is 10. |
442 const int kOverlap = 20; | 442 const int kOverlap = 20; |
443 offset = pre_write_usage - kOverlap; | 443 offset = pre_write_usage - kOverlap; |
444 allowed_growth = 10; | 444 allowed_growth = 10; |
445 PrepareForWrite("test", kBlobURL, offset, allowed_growth); | 445 PrepareForWrite("test", kBlobURL, offset, allowed_growth); |
446 | 446 |
447 { | 447 { |
448 Result result; | 448 Result result; |
449 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); | 449 file_writer_delegate_->Start(request_.Pass(), GetWriteCallback(&result)); |
450 base::MessageLoop::current()->Run(); | 450 base::MessageLoop::current()->Run(); |
451 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status()); | 451 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status()); |
452 file_writer_delegate_.reset(); | 452 file_writer_delegate_.reset(); |
453 | 453 |
454 EXPECT_EQ(pre_write_usage + allowed_growth, usage()); | 454 EXPECT_EQ(pre_write_usage + allowed_growth, usage()); |
455 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); | 455 EXPECT_EQ(GetFileSizeOnDisk("test"), usage()); |
456 EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written()); | 456 EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written()); |
457 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result.status()); | 457 EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status()); |
458 } | 458 } |
459 } | 459 } |
460 | 460 |
461 } // namespace content | 461 } // namespace content |
OLD | NEW |