Send OnModifyFile Notification when File Write Finishes

webkit/fileapi/file_writer_delegate_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop.h"
@@ skipping 13 matching lines @@
 
 namespace fileapi {
 
 namespace {
 
 class Result {
  public:
   Result()
       : status_(base::PLATFORM_FILE_OK),
         bytes_written_(0),
-        complete_(false) {}
+        write_status_(FileWriterDelegate::SUCCESS_IO_PENDING) {}
 
   base::PlatformFileError status() const { return status_; }
-  void add_bytes_written(int64 bytes, bool complete) {
-    bytes_written_ += bytes;
-    EXPECT_FALSE(complete_);
-    complete_ = complete;
-  }
   int64 bytes_written() const { return bytes_written_; }
-  bool complete() const { return complete_; }
+  bool write_status() const { return write_status_; }

[kinuko, 2012/09/26 06:31:15]

should this return WriteProgressStatus?

[calvinlo, 2012/09/26 07:43:40]

Done.

 
-  void DidWrite(base::PlatformFileError status, int64 bytes, bool complete) {
+  void DidWrite(base::PlatformFileError status, int64 bytes,
+                FileWriterDelegate::WriteProgressStatus write_status) {
+    write_status_ = write_status;
     if (status == base::PLATFORM_FILE_OK) {
-      add_bytes_written(bytes, complete);
-      if (complete)
+      bytes_written_ += bytes;
+      if (write_status_ != FileWriterDelegate::SUCCESS_IO_PENDING)
         MessageLoop::current()->Quit();
     } else {
-      EXPECT_FALSE(complete_);
-      EXPECT_EQ(status_, base::PLATFORM_FILE_OK);
-      complete_ = true;
+      EXPECT_EQ(base::PLATFORM_FILE_OK, status_);
       status_ = status;
       MessageLoop::current()->Quit();
     }
   }
 
  private:
   // For post-operation status.
   base::PlatformFileError status_;
   int64 bytes_written_;
-  bool complete_;
+  FileWriterDelegate::WriteProgressStatus write_status_;
 };
 
 const char kData[] = "The quick brown fox jumps over the lazy dog.\n";
 const int kDataSize = ARRAYSIZE_UNSAFE(kData) - 1;
 
 }  // namespace (anonymous)
 
 class FileWriterDelegateTest : public PlatformTest {
  public:
   FileWriterDelegateTest()
@@ skipping 156 matching lines @@
 TEST_F(FileWriterDelegateTest, MAYBE_WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
   PrepareForWrite(kBlobURL, 0, quota::QuotaManager::kNoLimit);
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
 
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
 }
 
 // FileWriterDelegateTest.WriteSuccessWithJustQuota is flaky on windows
 // http://crbug.com/130401
 #if defined(OS_WIN)
 #define MAYBE_WriteSuccessWithJustQuota DISABLED_WriteSuccessWithJustQuota
 #else
 #define MAYBE_WriteSuccessWithJustQuota WriteSuccessWithJustQuota
 #endif
 
 TEST_F(FileWriterDelegateTest, MAYBE_WriteSuccessWithJustQuota) {
   const GURL kBlobURL("blob:just");
   content_ = kData;
   const int64 kAllowedGrowth = kDataSize;
   PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
 }
 
 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) {
   const GURL kBlobURL("blob:failure");
   content_ = kData;
   const int64 kAllowedGrowth = kDataSize - 1;
   PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result_->write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status());
-  EXPECT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result_->write_status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   const GURL kBlobURL("blob:zero");
   content_ = "";
   int64 kAllowedGrowth = 0;
   PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
-  EXPECT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
 }
 
 #if defined(OS_WIN)
 // See http://crbug.com/129264
 #define MAYBE_WriteSuccessWithoutQuotaLimitConcurrent \
     DISABLED_WriteSuccessWithoutQuotaLimitConcurrent
 #else
 #define MAYBE_WriteSuccessWithoutQuotaLimitConcurrent \
     WriteSuccessWithoutQuotaLimitConcurrent
 #endif
@@ skipping 21 matching lines @@
   result2.reset(new Result());
   file_writer_delegate2.reset(CreateWriterDelegate(
       "test2", 0, quota::QuotaManager::kNoLimit, result2.get()));
   request2.reset(empty_context_.CreateRequest(
       kBlobURL2, file_writer_delegate2.get()));
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   file_writer_delegate2->Start(request2.Pass());
   MessageLoop::current()->Run();
-  if (!result_->complete() || !result2->complete())
+  if (result_->write_status() == FileWriterDelegate::SUCCESS_IO_PENDING ||
+      result2->write_status() == FileWriterDelegate::SUCCESS_IO_PENDING)
     MessageLoop::current()->Run();
 
-  ASSERT_TRUE(result_->complete());
-  ASSERT_TRUE(result2->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2->write_status());
   file_writer_delegate_.reset();
   file_writer_delegate2.reset();
 
   ASSERT_EQ(kDataSize * 2, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_EQ(kDataSize, result2->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result2->status());
@@ skipping 14 matching lines @@
 
   // Writing kDataSize (=45) bytes data while allowed_growth is 100.
   int64 offset = 0;
   int64 allowed_growth = 100;
   ASSERT_LT(kDataSize, allowed_growth);
   PrepareForWrite(kBlobURL, offset, allowed_growth);
 
   ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
 
   // Trying to overwrite kDataSize bytes data while allowed_growth is 20.
   offset = 0;
   allowed_growth = 20;
   PrepareForWrite(kBlobURL, offset, allowed_growth);
 
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
   EXPECT_EQ(kDataSize, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
-  EXPECT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
 
   // Trying to write kDataSize bytes data from offset 25 while
   // allowed_growth is 55.
   offset = 25;
   allowed_growth = 55;
   PrepareForWrite(kBlobURL, offset, allowed_growth);
 
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   EXPECT_EQ(offset + kDataSize, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
 
   // Trying to overwrite 45 bytes data while allowed_growth is -20.
   offset = 0;
   allowed_growth = -20;
   PrepareForWrite(kBlobURL, offset, allowed_growth);
 
   int64 pre_write_usage = ComputeCurrentOriginUsage();
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   EXPECT_EQ(pre_write_usage, test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
 
   // Trying to overwrite 45 bytes data with offset pre_write_usage - 20,
   // while allowed_growth is 10.
   const int kOverlap = 20;
   offset = pre_write_usage - kOverlap;
   allowed_growth = 10;
   PrepareForWrite(kBlobURL, offset, allowed_growth);
 
   file_writer_delegate_->Start(request_.Pass());
   MessageLoop::current()->Run();
-  ASSERT_TRUE(result_->complete());
+  ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result_->write_status());
   file_writer_delegate_.reset();
 
   EXPECT_EQ(pre_write_usage + allowed_growth,
             test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
   EXPECT_EQ(kOverlap + allowed_growth, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status());
 }
 
 }  // namespace fileapi