OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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/message_loop.h" | 10 #include "base/message_loop.h" |
(...skipping 13 matching lines...) Expand all Loading... |
24 | 24 |
25 namespace fileapi { | 25 namespace fileapi { |
26 | 26 |
27 namespace { | 27 namespace { |
28 | 28 |
29 class Result { | 29 class Result { |
30 public: | 30 public: |
31 Result() | 31 Result() |
32 : status_(base::PLATFORM_FILE_OK), | 32 : status_(base::PLATFORM_FILE_OK), |
33 bytes_written_(0), | 33 bytes_written_(0), |
34 complete_(false) {} | 34 write_status_(FileWriterDelegate::SUCCESS_IO_PENDING) {} |
35 | 35 |
36 base::PlatformFileError status() const { return status_; } | 36 base::PlatformFileError status() const { return status_; } |
37 void add_bytes_written(int64 bytes, bool complete) { | 37 int64 bytes_written() const { return bytes_written_; } |
38 bytes_written_ += bytes; | 38 FileWriterDelegate::WriteProgressStatus write_status() const { |
39 EXPECT_FALSE(complete_); | 39 return write_status_; |
40 complete_ = complete; | |
41 } | 40 } |
42 int64 bytes_written() const { return bytes_written_; } | |
43 bool complete() const { return complete_; } | |
44 | 41 |
45 void DidWrite(base::PlatformFileError status, int64 bytes, bool complete) { | 42 void DidWrite(base::PlatformFileError status, int64 bytes, |
| 43 FileWriterDelegate::WriteProgressStatus write_status) { |
| 44 write_status_ = write_status; |
46 if (status == base::PLATFORM_FILE_OK) { | 45 if (status == base::PLATFORM_FILE_OK) { |
47 add_bytes_written(bytes, complete); | 46 bytes_written_ += bytes; |
48 if (complete) | 47 if (write_status_ != FileWriterDelegate::SUCCESS_IO_PENDING) |
49 MessageLoop::current()->Quit(); | 48 MessageLoop::current()->Quit(); |
50 } else { | 49 } else { |
51 EXPECT_FALSE(complete_); | 50 EXPECT_EQ(base::PLATFORM_FILE_OK, status_); |
52 EXPECT_EQ(status_, base::PLATFORM_FILE_OK); | |
53 complete_ = true; | |
54 status_ = status; | 51 status_ = status; |
55 MessageLoop::current()->Quit(); | 52 MessageLoop::current()->Quit(); |
56 } | 53 } |
57 } | 54 } |
58 | 55 |
59 private: | 56 private: |
60 // For post-operation status. | 57 // For post-operation status. |
61 base::PlatformFileError status_; | 58 base::PlatformFileError status_; |
62 int64 bytes_written_; | 59 int64 bytes_written_; |
63 bool complete_; | 60 FileWriterDelegate::WriteProgressStatus write_status_; |
64 }; | 61 }; |
65 | 62 |
66 const char kData[] = "The quick brown fox jumps over the lazy dog.\n"; | 63 const char kData[] = "The quick brown fox jumps over the lazy dog.\n"; |
67 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1; | 64 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1; |
68 | 65 |
69 } // namespace (anonymous) | 66 } // namespace (anonymous) |
70 | 67 |
71 class FileWriterDelegateTest : public PlatformTest { | 68 class FileWriterDelegateTest : public PlatformTest { |
72 public: | 69 public: |
73 FileWriterDelegateTest() | 70 FileWriterDelegateTest() |
(...skipping 156 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
230 TEST_F(FileWriterDelegateTest, MAYBE_WriteSuccessWithoutQuotaLimit) { | 227 TEST_F(FileWriterDelegateTest, MAYBE_WriteSuccessWithoutQuotaLimit) { |
231 const GURL kBlobURL("blob:nolimit"); | 228 const GURL kBlobURL("blob:nolimit"); |
232 content_ = kData; | 229 content_ = kData; |
233 | 230 |
234 PrepareForWrite(kBlobURL, 0, quota::QuotaManager::kNoLimit); | 231 PrepareForWrite(kBlobURL, 0, quota::QuotaManager::kNoLimit); |
235 | 232 |
236 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); | 233 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); |
237 file_writer_delegate_->Start(request_.Pass()); | 234 file_writer_delegate_->Start(request_.Pass()); |
238 MessageLoop::current()->Run(); | 235 MessageLoop::current()->Run(); |
239 | 236 |
240 ASSERT_TRUE(result_->complete()); | 237 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
241 file_writer_delegate_.reset(); | 238 file_writer_delegate_.reset(); |
242 | 239 |
243 ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage()); | 240 ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage()); |
244 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 241 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
245 EXPECT_EQ(kDataSize, result_->bytes_written()); | 242 EXPECT_EQ(kDataSize, result_->bytes_written()); |
246 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 243 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
247 } | 244 } |
248 | 245 |
249 // FileWriterDelegateTest.WriteSuccessWithJustQuota is flaky on windows | 246 // FileWriterDelegateTest.WriteSuccessWithJustQuota is flaky on windows |
250 // http://crbug.com/130401 | 247 // http://crbug.com/130401 |
251 #if defined(OS_WIN) | 248 #if defined(OS_WIN) |
252 #define MAYBE_WriteSuccessWithJustQuota DISABLED_WriteSuccessWithJustQuota | 249 #define MAYBE_WriteSuccessWithJustQuota DISABLED_WriteSuccessWithJustQuota |
253 #else | 250 #else |
254 #define MAYBE_WriteSuccessWithJustQuota WriteSuccessWithJustQuota | 251 #define MAYBE_WriteSuccessWithJustQuota WriteSuccessWithJustQuota |
255 #endif | 252 #endif |
256 | 253 |
257 TEST_F(FileWriterDelegateTest, MAYBE_WriteSuccessWithJustQuota) { | 254 TEST_F(FileWriterDelegateTest, MAYBE_WriteSuccessWithJustQuota) { |
258 const GURL kBlobURL("blob:just"); | 255 const GURL kBlobURL("blob:just"); |
259 content_ = kData; | 256 content_ = kData; |
260 const int64 kAllowedGrowth = kDataSize; | 257 const int64 kAllowedGrowth = kDataSize; |
261 PrepareForWrite(kBlobURL, 0, kAllowedGrowth); | 258 PrepareForWrite(kBlobURL, 0, kAllowedGrowth); |
262 | 259 |
263 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); | 260 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); |
264 file_writer_delegate_->Start(request_.Pass()); | 261 file_writer_delegate_->Start(request_.Pass()); |
265 MessageLoop::current()->Run(); | 262 MessageLoop::current()->Run(); |
266 ASSERT_TRUE(result_->complete()); | 263 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
267 file_writer_delegate_.reset(); | 264 file_writer_delegate_.reset(); |
268 | 265 |
269 ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage()); | 266 ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage()); |
270 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 267 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
271 | 268 |
272 EXPECT_EQ(kAllowedGrowth, result_->bytes_written()); | 269 EXPECT_EQ(kAllowedGrowth, result_->bytes_written()); |
273 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 270 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
274 } | 271 } |
275 | 272 |
276 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) { | 273 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) { |
277 const GURL kBlobURL("blob:failure"); | 274 const GURL kBlobURL("blob:failure"); |
278 content_ = kData; | 275 content_ = kData; |
279 const int64 kAllowedGrowth = kDataSize - 1; | 276 const int64 kAllowedGrowth = kDataSize - 1; |
280 PrepareForWrite(kBlobURL, 0, kAllowedGrowth); | 277 PrepareForWrite(kBlobURL, 0, kAllowedGrowth); |
281 | 278 |
282 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); | 279 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); |
283 file_writer_delegate_->Start(request_.Pass()); | 280 file_writer_delegate_->Start(request_.Pass()); |
284 MessageLoop::current()->Run(); | 281 MessageLoop::current()->Run(); |
285 ASSERT_TRUE(result_->complete()); | 282 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result_->write_status()); |
286 file_writer_delegate_.reset(); | 283 file_writer_delegate_.reset(); |
287 | 284 |
288 ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage()); | 285 ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage()); |
289 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 286 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
290 | 287 |
291 EXPECT_EQ(kAllowedGrowth, result_->bytes_written()); | 288 EXPECT_EQ(kAllowedGrowth, result_->bytes_written()); |
292 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status()); | 289 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status()); |
293 EXPECT_TRUE(result_->complete()); | 290 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result_->write_status()); |
294 } | 291 } |
295 | 292 |
296 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) { | 293 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) { |
297 const GURL kBlobURL("blob:zero"); | 294 const GURL kBlobURL("blob:zero"); |
298 content_ = ""; | 295 content_ = ""; |
299 int64 kAllowedGrowth = 0; | 296 int64 kAllowedGrowth = 0; |
300 PrepareForWrite(kBlobURL, 0, kAllowedGrowth); | 297 PrepareForWrite(kBlobURL, 0, kAllowedGrowth); |
301 | 298 |
302 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); | 299 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); |
303 file_writer_delegate_->Start(request_.Pass()); | 300 file_writer_delegate_->Start(request_.Pass()); |
304 MessageLoop::current()->Run(); | 301 MessageLoop::current()->Run(); |
305 ASSERT_TRUE(result_->complete()); | 302 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
306 file_writer_delegate_.reset(); | 303 file_writer_delegate_.reset(); |
307 | 304 |
308 ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage()); | 305 ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage()); |
309 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 306 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
310 | 307 |
311 EXPECT_EQ(kAllowedGrowth, result_->bytes_written()); | 308 EXPECT_EQ(kAllowedGrowth, result_->bytes_written()); |
312 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 309 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
313 EXPECT_TRUE(result_->complete()); | 310 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
314 } | 311 } |
315 | 312 |
316 #if defined(OS_WIN) | 313 #if defined(OS_WIN) |
317 // See http://crbug.com/129264 | 314 // See http://crbug.com/129264 |
318 #define MAYBE_WriteSuccessWithoutQuotaLimitConcurrent \ | 315 #define MAYBE_WriteSuccessWithoutQuotaLimitConcurrent \ |
319 DISABLED_WriteSuccessWithoutQuotaLimitConcurrent | 316 DISABLED_WriteSuccessWithoutQuotaLimitConcurrent |
320 #else | 317 #else |
321 #define MAYBE_WriteSuccessWithoutQuotaLimitConcurrent \ | 318 #define MAYBE_WriteSuccessWithoutQuotaLimitConcurrent \ |
322 WriteSuccessWithoutQuotaLimitConcurrent | 319 WriteSuccessWithoutQuotaLimitConcurrent |
323 #endif | 320 #endif |
(...skipping 21 matching lines...) Expand all Loading... |
345 result2.reset(new Result()); | 342 result2.reset(new Result()); |
346 file_writer_delegate2.reset(CreateWriterDelegate( | 343 file_writer_delegate2.reset(CreateWriterDelegate( |
347 "test2", 0, quota::QuotaManager::kNoLimit, result2.get())); | 344 "test2", 0, quota::QuotaManager::kNoLimit, result2.get())); |
348 request2.reset(empty_context_.CreateRequest( | 345 request2.reset(empty_context_.CreateRequest( |
349 kBlobURL2, file_writer_delegate2.get())); | 346 kBlobURL2, file_writer_delegate2.get())); |
350 | 347 |
351 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); | 348 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); |
352 file_writer_delegate_->Start(request_.Pass()); | 349 file_writer_delegate_->Start(request_.Pass()); |
353 file_writer_delegate2->Start(request2.Pass()); | 350 file_writer_delegate2->Start(request2.Pass()); |
354 MessageLoop::current()->Run(); | 351 MessageLoop::current()->Run(); |
355 if (!result_->complete() || !result2->complete()) | 352 if (result_->write_status() == FileWriterDelegate::SUCCESS_IO_PENDING || |
| 353 result2->write_status() == FileWriterDelegate::SUCCESS_IO_PENDING) |
356 MessageLoop::current()->Run(); | 354 MessageLoop::current()->Run(); |
357 | 355 |
358 ASSERT_TRUE(result_->complete()); | 356 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
359 ASSERT_TRUE(result2->complete()); | 357 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2->write_status()); |
360 file_writer_delegate_.reset(); | 358 file_writer_delegate_.reset(); |
361 file_writer_delegate2.reset(); | 359 file_writer_delegate2.reset(); |
362 | 360 |
363 ASSERT_EQ(kDataSize * 2, test_helper_.GetCachedOriginUsage()); | 361 ASSERT_EQ(kDataSize * 2, test_helper_.GetCachedOriginUsage()); |
364 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 362 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
365 | 363 |
366 EXPECT_EQ(kDataSize, result_->bytes_written()); | 364 EXPECT_EQ(kDataSize, result_->bytes_written()); |
367 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 365 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
368 EXPECT_EQ(kDataSize, result2->bytes_written()); | 366 EXPECT_EQ(kDataSize, result2->bytes_written()); |
369 EXPECT_EQ(base::PLATFORM_FILE_OK, result2->status()); | 367 EXPECT_EQ(base::PLATFORM_FILE_OK, result2->status()); |
(...skipping 14 matching lines...) Expand all Loading... |
384 | 382 |
385 // Writing kDataSize (=45) bytes data while allowed_growth is 100. | 383 // Writing kDataSize (=45) bytes data while allowed_growth is 100. |
386 int64 offset = 0; | 384 int64 offset = 0; |
387 int64 allowed_growth = 100; | 385 int64 allowed_growth = 100; |
388 ASSERT_LT(kDataSize, allowed_growth); | 386 ASSERT_LT(kDataSize, allowed_growth); |
389 PrepareForWrite(kBlobURL, offset, allowed_growth); | 387 PrepareForWrite(kBlobURL, offset, allowed_growth); |
390 | 388 |
391 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); | 389 ASSERT_EQ(0, test_helper_.GetCachedOriginUsage()); |
392 file_writer_delegate_->Start(request_.Pass()); | 390 file_writer_delegate_->Start(request_.Pass()); |
393 MessageLoop::current()->Run(); | 391 MessageLoop::current()->Run(); |
394 ASSERT_TRUE(result_->complete()); | 392 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
395 file_writer_delegate_.reset(); | 393 file_writer_delegate_.reset(); |
396 | 394 |
397 ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage()); | 395 ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage()); |
398 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 396 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
399 EXPECT_EQ(kDataSize, result_->bytes_written()); | 397 EXPECT_EQ(kDataSize, result_->bytes_written()); |
400 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 398 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
401 | 399 |
402 // Trying to overwrite kDataSize bytes data while allowed_growth is 20. | 400 // Trying to overwrite kDataSize bytes data while allowed_growth is 20. |
403 offset = 0; | 401 offset = 0; |
404 allowed_growth = 20; | 402 allowed_growth = 20; |
405 PrepareForWrite(kBlobURL, offset, allowed_growth); | 403 PrepareForWrite(kBlobURL, offset, allowed_growth); |
406 | 404 |
407 file_writer_delegate_->Start(request_.Pass()); | 405 file_writer_delegate_->Start(request_.Pass()); |
408 MessageLoop::current()->Run(); | 406 MessageLoop::current()->Run(); |
409 EXPECT_EQ(kDataSize, test_helper_.GetCachedOriginUsage()); | 407 EXPECT_EQ(kDataSize, test_helper_.GetCachedOriginUsage()); |
410 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 408 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
411 EXPECT_EQ(kDataSize, result_->bytes_written()); | 409 EXPECT_EQ(kDataSize, result_->bytes_written()); |
412 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 410 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
413 EXPECT_TRUE(result_->complete()); | 411 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
414 | 412 |
415 // Trying to write kDataSize bytes data from offset 25 while | 413 // Trying to write kDataSize bytes data from offset 25 while |
416 // allowed_growth is 55. | 414 // allowed_growth is 55. |
417 offset = 25; | 415 offset = 25; |
418 allowed_growth = 55; | 416 allowed_growth = 55; |
419 PrepareForWrite(kBlobURL, offset, allowed_growth); | 417 PrepareForWrite(kBlobURL, offset, allowed_growth); |
420 | 418 |
421 file_writer_delegate_->Start(request_.Pass()); | 419 file_writer_delegate_->Start(request_.Pass()); |
422 MessageLoop::current()->Run(); | 420 MessageLoop::current()->Run(); |
423 ASSERT_TRUE(result_->complete()); | 421 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
424 file_writer_delegate_.reset(); | 422 file_writer_delegate_.reset(); |
425 | 423 |
426 EXPECT_EQ(offset + kDataSize, test_helper_.GetCachedOriginUsage()); | 424 EXPECT_EQ(offset + kDataSize, test_helper_.GetCachedOriginUsage()); |
427 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 425 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
428 EXPECT_EQ(kDataSize, result_->bytes_written()); | 426 EXPECT_EQ(kDataSize, result_->bytes_written()); |
429 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 427 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
430 | 428 |
431 // Trying to overwrite 45 bytes data while allowed_growth is -20. | 429 // Trying to overwrite 45 bytes data while allowed_growth is -20. |
432 offset = 0; | 430 offset = 0; |
433 allowed_growth = -20; | 431 allowed_growth = -20; |
434 PrepareForWrite(kBlobURL, offset, allowed_growth); | 432 PrepareForWrite(kBlobURL, offset, allowed_growth); |
435 | 433 |
436 int64 pre_write_usage = ComputeCurrentOriginUsage(); | 434 int64 pre_write_usage = ComputeCurrentOriginUsage(); |
437 file_writer_delegate_->Start(request_.Pass()); | 435 file_writer_delegate_->Start(request_.Pass()); |
438 MessageLoop::current()->Run(); | 436 MessageLoop::current()->Run(); |
439 ASSERT_TRUE(result_->complete()); | 437 ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status()); |
440 file_writer_delegate_.reset(); | 438 file_writer_delegate_.reset(); |
441 | 439 |
442 EXPECT_EQ(pre_write_usage, test_helper_.GetCachedOriginUsage()); | 440 EXPECT_EQ(pre_write_usage, test_helper_.GetCachedOriginUsage()); |
443 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 441 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
444 EXPECT_EQ(kDataSize, result_->bytes_written()); | 442 EXPECT_EQ(kDataSize, result_->bytes_written()); |
445 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); | 443 EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status()); |
446 | 444 |
447 // Trying to overwrite 45 bytes data with offset pre_write_usage - 20, | 445 // Trying to overwrite 45 bytes data with offset pre_write_usage - 20, |
448 // while allowed_growth is 10. | 446 // while allowed_growth is 10. |
449 const int kOverlap = 20; | 447 const int kOverlap = 20; |
450 offset = pre_write_usage - kOverlap; | 448 offset = pre_write_usage - kOverlap; |
451 allowed_growth = 10; | 449 allowed_growth = 10; |
452 PrepareForWrite(kBlobURL, offset, allowed_growth); | 450 PrepareForWrite(kBlobURL, offset, allowed_growth); |
453 | 451 |
454 file_writer_delegate_->Start(request_.Pass()); | 452 file_writer_delegate_->Start(request_.Pass()); |
455 MessageLoop::current()->Run(); | 453 MessageLoop::current()->Run(); |
456 ASSERT_TRUE(result_->complete()); | 454 ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result_->write_status()); |
457 file_writer_delegate_.reset(); | 455 file_writer_delegate_.reset(); |
458 | 456 |
459 EXPECT_EQ(pre_write_usage + allowed_growth, | 457 EXPECT_EQ(pre_write_usage + allowed_growth, |
460 test_helper_.GetCachedOriginUsage()); | 458 test_helper_.GetCachedOriginUsage()); |
461 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); | 459 EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage()); |
462 EXPECT_EQ(kOverlap + allowed_growth, result_->bytes_written()); | 460 EXPECT_EQ(kOverlap + allowed_growth, result_->bytes_written()); |
463 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status()); | 461 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status()); |
464 } | 462 } |
465 | 463 |
466 } // namespace fileapi | 464 } // namespace fileapi |
OLD | NEW |