Revert 86978 - Fix FileWriterDelegate's usage tracking behavior

- allowed_growth can be negative if the current usage is larger than the quota; in that case we shouldn't crash (there was a DCHECK that is checking it)
- fixed 'delta' size in update notification for overwriting cases
- now it respects 'unlimitedStorage' settings

BUG=74841
TEST=FileWriterDelegate.WriteWithQuotaAndOffset

Review URL: http://codereview.chromium.org/7067021

TBR=kinuko@chromium.org
Review URL: http://codereview.chromium.org/6962037

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@86981 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 121 insertions, 345 deletions

diff --git a/webkit/fileapi/file_system_test_helper.cc b/webkit/fileapi/file_system_test_helper.cc
index bef48ba..dd2334b 100644
--- a/webkit/fileapi/file_system_test_helper.cc
+++ b/webkit/fileapi/file_system_test_helper.cc
@@ -23,7 +23,7 @@ namespace {
 
 class TestSpecialStoragePolicy : public quota::SpecialStoragePolicy {
  public:
-  explicit TestSpecialStoragePolicy(bool unlimited_quota)
+  TestSpecialStoragePolicy(bool unlimited_quota)
       : unlimited_quota_(unlimited_quota) {}
 
   virtual bool IsStorageProtected(const GURL& origin) {
@@ -92,15 +92,7 @@ void FileSystemTestOriginHelper::SetUp(
   // Initialize the usage cache file.
   FilePath usage_cache_path = file_system_context_->path_manager()
       ->sandbox_provider()->GetUsageCachePathForOriginAndType(origin_, type_);
-  FileSystemUsageCache::UpdateUsage(
-      usage_cache_path, FileSystemUsageCache::kUsageFileSize);
-
-  // We expect the origin directory to be always empty, except for possibly
-  // the usage cache file.  We record the initial usage file size here
-  // (it will be either 0 or kUsageFileSize) so that later we can compute
-  // how much the size of the origin directory has grown.
-  initial_usage_size_ = file_util::ComputeDirectorySize(
-      GetOriginRootPath());
+  FileSystemUsageCache::UpdateUsage(usage_cache_path, 0);
 }
 
 void FileSystemTestOriginHelper::TearDown() {
@@ -137,19 +129,6 @@ FilePath FileSystemTestOriginHelper::GetUsageCachePath() const {
       ->sandbox_provider()->GetUsageCachePathForOriginAndType(origin_, type_);
 }
 
-int64 FileSystemTestOriginHelper::GetCachedOriginUsage() const {
-  return FileSystemUsageCache::GetUsage(GetUsageCachePath()) -
-      FileSystemUsageCache::kUsageFileSize;
-}
-
-int64 FileSystemTestOriginHelper::ComputeCurrentOriginUsage() const {
-  // Depending on the file_util GetOriginRootPath() may include usage
-  // cache file size or may not.  Here we subtract the initial size to
-  // make it work for multiple file_utils.
-  return file_util::ComputeDirectorySize(GetOriginRootPath()) -
-      initial_usage_size_;
-}
-
 FileSystemOperation* FileSystemTestOriginHelper::NewOperation(
     FileSystemCallbackDispatcher* callback_dispatcher) {
   DCHECK(file_system_context_.get());
diff --git a/webkit/fileapi/file_system_test_helper.h b/webkit/fileapi/file_system_test_helper.h
index c813cf7..2cf8ebb 100644
--- a/webkit/fileapi/file_system_test_helper.h
+++ b/webkit/fileapi/file_system_test_helper.h
@@ -53,9 +53,6 @@ class FileSystemTestOriginHelper {
   GURL GetURLForPath(const FilePath& path) const;
   FilePath GetUsageCachePath() const;
 
-  int64 GetCachedOriginUsage() const;
-  int64 ComputeCurrentOriginUsage() const;
-
   FileSystemOperation* NewOperation(
       FileSystemCallbackDispatcher* callback_dispatcher);
   FileSystemOperationContext* NewOperationContext();
@@ -78,7 +75,6 @@ class FileSystemTestOriginHelper {
   const GURL origin_;
   const FileSystemType type_;
   FileSystemFileUtil* file_util_;
-  int64 initial_usage_size_;
 };
 
 }  // namespace fileapi
diff --git a/webkit/fileapi/file_writer_delegate.cc b/webkit/fileapi/file_writer_delegate.cc
index 83287da..38e7260 100644
--- a/webkit/fileapi/file_writer_delegate.cc
+++ b/webkit/fileapi/file_writer_delegate.cc
@@ -35,7 +35,7 @@ class InitializeTask : public base::RefCountedThreadSafe<InitializeTask> {
             base::MessageLoopProxy::CreateForCurrentThread()),
         error_code_(base::PLATFORM_FILE_OK),
         file_(file),
-        context_(*context),
+        context_(context),
         callback_(callback) {
     DCHECK(callback);
   }
@@ -55,13 +55,13 @@ class InitializeTask : public base::RefCountedThreadSafe<InitializeTask> {
   }
 
   void ProcessOnTargetThread() {
-    DCHECK(context_.file_system_context());
-    FileSystemQuotaUtil* quota_util = context_.file_system_context()->
-        GetQuotaUtil(context_.src_type());
+    DCHECK(context_->file_system_context());
+    FileSystemQuotaUtil* quota_util = context_->file_system_context()->
+        GetQuotaUtil(context_->src_type());
     if (quota_util) {
       DCHECK(quota_util->proxy());
       quota_util->proxy()->StartUpdateOrigin(
-          context_.src_origin_url(), context_.src_type());
+          context_->src_origin_url(), context_->src_type());
     }
     if (!base::GetPlatformFileInfo(file_, &file_info_))
       error_code_ = base::PLATFORM_FILE_ERROR_FAILED;
@@ -73,7 +73,7 @@ class InitializeTask : public base::RefCountedThreadSafe<InitializeTask> {
   base::PlatformFileError error_code_;
 
   base::PlatformFile file_;
-  FileSystemOperationContext context_;
+  FileSystemOperationContext* context_;
   InitializeTaskCallback* callback_;
 
   base::PlatformFileInfo file_info_;
@@ -88,7 +88,7 @@ FileWriterDelegate::FileWriterDelegate(
       file_(base::kInvalidPlatformFileValue),
       offset_(offset),
       proxy_(proxy),
-      bytes_written_backlog_(0),
+      bytes_read_backlog_(0),
       bytes_written_(0),
       bytes_read_(0),
       total_bytes_written_(0),
@@ -110,22 +110,10 @@ void FileWriterDelegate::OnGetFileInfoAndCallStartUpdate(
     OnError(error);
     return;
   }
-  int64 allowed_bytes_growth =
-      file_system_operation_context()->allowed_bytes_growth();
-  if (allowed_bytes_growth == QuotaFileUtil::kNoLimit ||
-      file_system_operation_->file_system_context()->IsStorageUnlimited(
-          file_system_operation_context()->src_origin_url())) {
-    // TODO(kinuko): kNoLimit is kint64max therefore all the calculation/
-    // comparison with the value should just work, but we should drop
-    // such implicit assumption and should use an explicit boolean flag
-    // or something.
+  if (allowed_bytes_growth_ != QuotaFileUtil::kNoLimit)
+    allowed_bytes_to_write_ = file_info.size - offset_ + allowed_bytes_growth_;
+  else
     allowed_bytes_to_write_ = QuotaFileUtil::kNoLimit;
-  } else {
-    if (allowed_bytes_growth < 0)
-      allowed_bytes_growth = 0;
-    allowed_bytes_to_write_ = file_info.size - offset_ + allowed_bytes_growth;
-  }
-  size_ = file_info.size;
   file_stream_.reset(new net::FileStream(file_,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
       base::PLATFORM_FILE_ASYNC));
@@ -136,6 +124,8 @@ void FileWriterDelegate::Start(base::PlatformFile file,
                                net::URLRequest* request) {
   file_ = file;
   request_ = request;
+  allowed_bytes_growth_ =
+      file_system_operation_context()->allowed_bytes_growth();
 
   scoped_refptr<InitializeTask> relay = new InitializeTask(
       file_, file_system_operation_context(),
@@ -221,12 +211,7 @@ void FileWriterDelegate::OnDataReceived(int bytes_read) {
 }
 
 void FileWriterDelegate::Write() {
-  // allowed_bytes_to_write could be negative if the file size is
-  // greater than the current (possibly new) quota.
-  // (The UI should clear the entire origin data if the smaller quota size
-  // is set in general, though the UI/deletion code is not there yet.)
-  DCHECK(total_bytes_written_ <= allowed_bytes_to_write_ ||
-         allowed_bytes_to_write_ < 0);
+  DCHECK(total_bytes_written_ <= allowed_bytes_to_write_);
   if (total_bytes_written_ >= allowed_bytes_to_write_) {
     OnError(base::PLATFORM_FILE_ERROR_NO_SPACE);
     return;
@@ -275,27 +260,23 @@ void FileWriterDelegate::OnError(base::PlatformFileError error) {
   file_system_operation_->DidWrite(error, 0, true);
 }
 
-void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
-  DCHECK(bytes_written + bytes_written_backlog_ >= bytes_written_backlog_);
-  if (bytes_written > 0 &&
-      total_bytes_written_ + bytes_written + offset_ > size_) {
-    int overlapped = 0;
-    if (total_bytes_written_ + offset_ < size_)
-      overlapped = size_ - total_bytes_written_ - offset_;
+void FileWriterDelegate::OnProgress(int bytes_read, bool done) {
+  DCHECK(bytes_read + bytes_read_backlog_ >= bytes_read_backlog_);
+  if (bytes_read > 0 && quota_util()) {
     quota_util()->proxy()->UpdateOriginUsage(
         file_system_operation_->file_system_context()->quota_manager_proxy(),
         file_system_operation_context()->src_origin_url(),
         file_system_operation_context()->src_type(),
-        bytes_written - overlapped);
+        bytes_read);
   }
   static const int kMinProgressDelayMS = 200;
   base::Time currentTime = base::Time::Now();
   if (done || last_progress_event_time_.is_null() ||
       (currentTime - last_progress_event_time_).InMilliseconds() >
           kMinProgressDelayMS) {
-    bytes_written += bytes_written_backlog_;
+    bytes_read += bytes_read_backlog_;
     last_progress_event_time_ = currentTime;
-    bytes_written_backlog_ = 0;
+    bytes_read_backlog_ = 0;
     if (done && quota_util()) {
       if (quota_util()) {
         quota_util()->proxy()->EndUpdateOrigin(
@@ -303,11 +284,10 @@ void FileWriterDelegate::OnProgress(int bytes_written, bool done) {
             file_system_operation_context()->src_type());
       }
     }
-    file_system_operation_->DidWrite(
-        base::PLATFORM_FILE_OK, bytes_written, done);
+    file_system_operation_->DidWrite(base::PLATFORM_FILE_OK, bytes_read, done);
     return;
   }
-  bytes_written_backlog_ += bytes_written;
+  bytes_read_backlog_ += bytes_read;
 }
 
 FileSystemOperationContext*
diff --git a/webkit/fileapi/file_writer_delegate.h b/webkit/fileapi/file_writer_delegate.h
index 6d94e6e..cf59e5a 100644
--- a/webkit/fileapi/file_writer_delegate.h
+++ b/webkit/fileapi/file_writer_delegate.h
@@ -65,14 +65,15 @@ class FileWriterDelegate : public net::URLRequest::Delegate {
 
   FileSystemOperation* file_system_operation_;
   base::PlatformFile file_;
-  int64 size_;
+  base::PlatformFileInfo file_info_;
   int64 offset_;
   scoped_refptr<base::MessageLoopProxy> proxy_;
   base::Time last_progress_event_time_;
-  int bytes_written_backlog_;
+  int bytes_read_backlog_;
   int bytes_written_;
   int bytes_read_;
   int64 total_bytes_written_;
+  int64 allowed_bytes_growth_;
   int64 allowed_bytes_to_write_;
   scoped_refptr<net::IOBufferWithSize> io_buffer_;
   scoped_ptr<net::FileStream> file_stream_;
diff --git a/webkit/fileapi/file_writer_delegate_unittest.cc b/webkit/fileapi/file_writer_delegate_unittest.cc
index 27bf0f1..1d07fd8 100644
--- a/webkit/fileapi/file_writer_delegate_unittest.cc
+++ b/webkit/fileapi/file_writer_delegate_unittest.cc
@@ -11,7 +11,6 @@
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/file_util_proxy.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
@@ -66,49 +65,19 @@ class Result {
   bool complete_;
 };
 
-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()
-      : loop_(MessageLoop::TYPE_IO),
-        file_(base::kInvalidPlatformFileValue) {}
+      : loop_(MessageLoop::TYPE_IO) {}
 
  protected:
   virtual void SetUp();
   virtual void TearDown();
 
-  virtual void SetUpTestHelper(const FilePath& base_dir) {
-    test_helper_.SetUp(base_dir, QuotaFileUtil::GetInstance());
-  }
-
-  int64 ComputeCurrentOriginUsage() {
-    base::FlushPlatformFile(file_);
-    return test_helper_.ComputeCurrentOriginUsage();
-  }
-
-  // Creates and sets up a FileWriterDelegate for writing the given |blob_url|
-  // to a file (file_) from |offset| with |allowed_growth| quota setting.
-  void PrepareForWrite(const GURL& blob_url,
-                       int64 offset,
-                       int64 allowed_growth) {
-    bool created;
-    base::PlatformFileError error_code;
-    file_ = base::CreatePlatformFile(
-        file_path_,
-        base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
-            base::PLATFORM_FILE_ASYNC,
-        &created, &error_code);
-    ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
-
-    result_.reset(new Result());
-    file_writer_delegate_.reset(new FileWriterDelegate(
-        CreateNewOperation(result_.get(), allowed_growth),
-        offset, base::MessageLoopProxy::CreateForCurrentThread()));
-    request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
+  int64 GetCachedUsage() {
+    return FileSystemUsageCache::GetUsage(test_helper_.GetUsageCachePath());
   }
 
   FileSystemOperation* CreateNewOperation(Result* result, int64 quota);
@@ -121,6 +90,7 @@ class FileWriterDelegateTest : public PlatformTest {
   FileSystemTestOriginHelper test_helper_;
 
   MessageLoop loop_;
+
   ScopedTempDir dir_;
   FilePath file_path_;
   PlatformFile file_;
@@ -219,14 +189,29 @@ net::URLRequestJob* FileWriterDelegateTest::Factory(
 void FileWriterDelegateTest::SetUp() {
   ASSERT_TRUE(dir_.CreateUniqueTempDir());
   FilePath base_dir = dir_.path().AppendASCII("filesystem");
-  SetUpTestHelper(base_dir);
+  test_helper_.SetUp(base_dir, QuotaFileUtil::GetInstance());
+
+  FilePath filesystem_dir = test_helper_.GetOriginRootPath();
+
   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(
-      test_helper_.GetOriginRootPath(), &file_path_));
+      filesystem_dir, &file_path_));
+  bool created;
+  base::PlatformFileError error_code;
+  file_ = base::CreatePlatformFile(
+      file_path_,
+      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
+          base::PLATFORM_FILE_ASYNC,
+      &created, &error_code);
+  ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
+
+  result_.reset(new Result());
+
   net::URLRequest::RegisterProtocolFactory("blob", &Factory);
 }
 
 void FileWriterDelegateTest::TearDown() {
   net::URLRequest::RegisterProtocolFactory("blob", NULL);
+  result_.reset();
   base::ClosePlatformFile(file_);
   test_helper_.TearDown();
 }
@@ -242,18 +227,19 @@ FileSystemOperation* FileWriterDelegateTest::CreateNewOperation(
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
-  const GURL kBlobURL("blob:nolimit");
-  content_ = kData;
-
-  PrepareForWrite(kBlobURL, 0, QuotaFileUtil::kNoLimit);
+  GURL blob_url("blob:nolimit");
+  content_ = "The quick brown fox jumps over the lazy dog.\n";
+  file_writer_delegate_.reset(new FileWriterDelegate(
+      CreateNewOperation(result_.get(), QuotaFileUtil::kNoLimit),
+      0, base::MessageLoopProxy::CreateForCurrentThread()));
+  request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
 
-  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kDataSize, test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(45, GetCachedUsage());
 
-  EXPECT_EQ(kDataSize, result_->bytes_written());
+  EXPECT_EQ(45, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_TRUE(result_->complete());
 
@@ -261,58 +247,61 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
-  const GURL kBlobURL("blob:just");
-  content_ = kData;
-  const int64 kAllowedGrowth = kDataSize;
-  PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
+  GURL blob_url("blob:just");
+  content_ = "The quick brown fox jumps over the lazy dog.\n";
+  file_writer_delegate_.reset(new FileWriterDelegate(
+      CreateNewOperation(result_.get(), 45),
+      0, base::MessageLoopProxy::CreateForCurrentThread()));
+  request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
 
-  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(45, GetCachedUsage());
 
   file_writer_delegate_.reset();
 
-  EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
+  EXPECT_EQ(45, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_TRUE(result_->complete());
 }
 
 TEST_F(FileWriterDelegateTest, WriteFailureByQuota) {
-  const GURL kBlobURL("blob:failure");
-  content_ = kData;
-  const int64 kAllowedGrowth = kDataSize - 1;
-  PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
+  GURL blob_url("blob:failure");
+  content_ = "The quick brown fox jumps over the lazy dog.\n";
+  file_writer_delegate_.reset(new FileWriterDelegate(
+      CreateNewOperation(result_.get(), 44),
+      0, base::MessageLoopProxy::CreateForCurrentThread()));
+  request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
 
-  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(44, GetCachedUsage());
 
   file_writer_delegate_.reset();
 
-  EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
+  EXPECT_EQ(44, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, result_->status());
   EXPECT_TRUE(result_->complete());
 }
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
-  const GURL kBlobURL("blob:zero");
+  GURL blob_url("blob:zero");
   content_ = "";
-  int64 kAllowedGrowth = 0;
-  PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
+  file_writer_delegate_.reset(new FileWriterDelegate(
+      CreateNewOperation(result_.get(), 0),
+      0, base::MessageLoopProxy::CreateForCurrentThread()));
+  request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
 
-  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
 
   file_writer_delegate_.reset();
 
-  EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
+  EXPECT_EQ(0, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_TRUE(result_->complete());
 }
@@ -322,161 +311,46 @@ TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
   scoped_ptr<net::URLRequest> request2;
   scoped_ptr<Result> result2;
 
-  FilePath file_path2;
   PlatformFile file2;
   bool created;
   base::PlatformFileError error_code;
-  ASSERT_TRUE(file_util::CreateTemporaryFileInDir(
-      test_helper_.GetOriginRootPath(), &file_path2));
   file2 = base::CreatePlatformFile(
-      file_path2,
+      file_path_,
       base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE |
           base::PLATFORM_FILE_ASYNC,
       &created, &error_code);
   ASSERT_EQ(base::PLATFORM_FILE_OK, error_code);
 
-  const GURL kBlobURL("blob:nolimitconcurrent");
-  const GURL kBlobURL2("blob:nolimitconcurrent2");
-  content_ = kData;
-
-  PrepareForWrite(kBlobURL, 0, QuotaFileUtil::kNoLimit);
-
-  // Credate another FileWriterDelegate for concurrent write.
   result2.reset(new Result());
+
+  GURL blob_url("blob:nolimitconcurrent");
+  GURL blob_url2("blob:nolimitconcurrent2");
+  content_ = "The quick brown fox jumps over the lazy dog.\n";
+  file_writer_delegate_.reset(new FileWriterDelegate(
+      CreateNewOperation(result_.get(), QuotaFileUtil::kNoLimit),
+      0, base::MessageLoopProxy::CreateForCurrentThread()));
   file_writer_delegate2.reset(new FileWriterDelegate(
       CreateNewOperation(result2.get(), QuotaFileUtil::kNoLimit),
       0, base::MessageLoopProxy::CreateForCurrentThread()));
-  request2.reset(new net::URLRequest(kBlobURL2, file_writer_delegate2.get()));
+  request_.reset(new net::URLRequest(blob_url, file_writer_delegate_.get()));
+  request2.reset(new net::URLRequest(blob_url2, file_writer_delegate2.get()));
 
-  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
   file_writer_delegate_->Start(file_, request_.get());
   file_writer_delegate2->Start(file2, request2.get());
   MessageLoop::current()->Run();
   if (!result_->complete() || !result2->complete())
     MessageLoop::current()->Run();
-
-  ASSERT_EQ(kDataSize * 2, test_helper_.GetCachedOriginUsage());
-  base::FlushPlatformFile(file2);
-  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(90, GetCachedUsage());
 
   file_writer_delegate_.reset();
 
-  EXPECT_EQ(kDataSize, result_->bytes_written());
+  EXPECT_EQ(45, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_TRUE(result_->complete());
-  EXPECT_EQ(kDataSize, result2->bytes_written());
+  EXPECT_EQ(45, result2->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result2->status());
   EXPECT_TRUE(result2->complete());
-
-  base::ClosePlatformFile(file2);
-}
-
-TEST_F(FileWriterDelegateTest, WritesWithQuotaAndOffset) {
-  const GURL kBlobURL("blob:failure-with-updated-quota");
-  content_ = kData;
-
-  // 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(file_, request_.get());
-  MessageLoop::current()->Run();
-  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());
-  EXPECT_TRUE(result_->complete());
-
-  // 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(file_, request_.get());
-  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());
-
-  // 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(file_, request_.get());
-  MessageLoop::current()->Run();
-  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());
-  EXPECT_TRUE(result_->complete());
-
-  // 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(file_, request_.get());
-  MessageLoop::current()->Run();
-  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());
-  EXPECT_TRUE(result_->complete());
-
-  // 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(file_, request_.get());
-  MessageLoop::current()->Run();
-  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());
-  EXPECT_TRUE(result_->complete());
-}
-
-class FileWriterDelegateUnlimitedTest : public FileWriterDelegateTest {
- protected:
-  virtual void SetUpTestHelper(const FilePath& path) OVERRIDE;
-};
-
-void FileWriterDelegateUnlimitedTest::SetUpTestHelper(const FilePath& path) {
-  test_helper_.SetUp(
-      path,
-      false /* incognito */,
-      true /* unlimited */,
-      NULL /* quota manager proxy */,
-      QuotaFileUtil::GetInstance());
-}
-
-TEST_F(FileWriterDelegateUnlimitedTest, WriteWithQuota) {
-  const GURL kBlobURL("blob:with-unlimited");
-  content_ = kData;
-
-  // Set small allowed_growth bytes
-  PrepareForWrite(kBlobURL, 0, 10);
-
-  // We shouldn't fail as the context is configured as 'unlimited'.
-  file_writer_delegate_->Start(file_, request_.get());
-  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());
 }
 
 }  // namespace fileapi
diff --git a/webkit/fileapi/quota_file_util_unittest.cc b/webkit/fileapi/quota_file_util_unittest.cc
index 4043ba3..3322bd6 100644
--- a/webkit/fileapi/quota_file_util_unittest.cc
+++ b/webkit/fileapi/quota_file_util_unittest.cc
@@ -72,10 +72,6 @@ class QuotaFileUtilTest : public testing::Test {
         quota_test_helper_.GetUsageCachePath());
   }
 
-  const FileSystemTestOriginHelper& test_helper() const {
-    return test_helper_;
-  }
-
  private:
   ScopedTempDir data_dir_;
   FileSystemTestOriginHelper local_test_helper_;
@@ -123,9 +119,7 @@ TEST_F(QuotaFileUtilTest, Truncate) {
             QuotaFileUtil::GetInstance()->Truncate(truncate_context.get(),
                                                    Path(file_name),
                                                    1020));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   truncate_context.reset(NewContext());
   truncate_context->set_allowed_bytes_growth(0);
@@ -133,9 +127,7 @@ TEST_F(QuotaFileUtilTest, Truncate) {
             QuotaFileUtil::GetInstance()->Truncate(truncate_context.get(),
                                                    Path(file_name),
                                                    0));
-  ASSERT_EQ(0, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
 
   truncate_context.reset(NewContext());
   truncate_context->set_allowed_bytes_growth(1020);
@@ -143,9 +135,7 @@ TEST_F(QuotaFileUtilTest, Truncate) {
             QuotaFileUtil::GetInstance()->Truncate(truncate_context.get(),
                                                    Path(file_name),
                                                    1021));
-  ASSERT_EQ(0, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
 }
 
 TEST_F(QuotaFileUtilTest, CopyFile) {
@@ -166,9 +156,7 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(from_file),
                                                    1020));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -176,9 +164,7 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(obstacle_file),
                                                    1));
-  ASSERT_EQ(1021, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1021, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1020);
@@ -186,9 +172,7 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
             QuotaFileUtil::GetInstance()->Copy(context.get(),
                                                Path(from_file),
                                                Path(to_file1)));
-  ASSERT_EQ(2041, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2041, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -196,9 +180,7 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
             QuotaFileUtil::GetInstance()->Copy(context.get(),
                                                Path(from_file),
                                                Path(to_file2)));
-  ASSERT_EQ(2041, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2041, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -206,9 +188,7 @@ TEST_F(QuotaFileUtilTest, CopyFile) {
             QuotaFileUtil::GetInstance()->Copy(context.get(),
                                                Path(from_file),
                                                Path(obstacle_file)));
-  ASSERT_EQ(3060, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(3060, GetCachedUsage());
 }
 
 TEST_F(QuotaFileUtilTest, CopyDirectory) {
@@ -233,9 +213,7 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(from_file),
                                                    1020));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1020);
@@ -243,9 +221,7 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
             QuotaFileUtil::GetInstance()->Copy(context.get(),
                                                Path(from_dir),
                                                Path(to_dir1)));
-  ASSERT_EQ(2040, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2040, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -253,9 +229,7 @@ TEST_F(QuotaFileUtilTest, CopyDirectory) {
             QuotaFileUtil::GetInstance()->Copy(context.get(),
                                                Path(from_dir),
                                                Path(to_dir2)));
-  ASSERT_EQ(2040, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2040, GetCachedUsage());
 }
 
 TEST_F(QuotaFileUtilTest, MoveFile) {
@@ -273,9 +247,7 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(from_file),
                                                    1020));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(0);
@@ -283,9 +255,7 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
             QuotaFileUtil::GetInstance()->Move(context.get(),
                                                Path(from_file),
                                                Path(to_file)));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(from_file, &created));
   ASSERT_TRUE(created);
@@ -298,9 +268,7 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(from_file),
                                                    1020));
-  ASSERT_EQ(2040, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2040, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -308,9 +276,7 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(obstacle_file),
                                                    1));
-  ASSERT_EQ(2041, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2041, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(0);
@@ -318,9 +284,7 @@ TEST_F(QuotaFileUtilTest, MoveFile) {
             QuotaFileUtil::GetInstance()->Move(context.get(),
                                                Path(from_file),
                                                Path(obstacle_file)));
-  ASSERT_EQ(2040, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2040, GetCachedUsage());
 }
 
 TEST_F(QuotaFileUtilTest, MoveDirectory) {
@@ -345,9 +309,7 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(from_file),
                                                    1020));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1020);
@@ -355,9 +317,7 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
             QuotaFileUtil::GetInstance()->Move(context.get(),
                                                Path(from_dir),
                                                Path(to_dir1)));
-  ASSERT_EQ(1020, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1020, GetCachedUsage());
 
   context.reset(NewContext());
   ASSERT_EQ(base::PLATFORM_FILE_OK,
@@ -373,9 +333,7 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(from_file),
                                                    1020));
-  ASSERT_EQ(2040, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2040, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(1019);
@@ -383,9 +341,7 @@ TEST_F(QuotaFileUtilTest, MoveDirectory) {
             QuotaFileUtil::GetInstance()->Move(context.get(),
                                                Path(from_dir),
                                                Path(to_dir2)));
-  ASSERT_EQ(2040, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(2040, GetCachedUsage());
 }
 
 TEST_F(QuotaFileUtilTest, Remove) {
@@ -414,9 +370,7 @@ TEST_F(QuotaFileUtilTest, Remove) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(file),
                                                    340));
-  ASSERT_EQ(340, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(340, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -424,9 +378,7 @@ TEST_F(QuotaFileUtilTest, Remove) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(dfile1),
                                                    1020));
-  ASSERT_EQ(1360, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1360, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -434,9 +386,7 @@ TEST_F(QuotaFileUtilTest, Remove) {
             QuotaFileUtil::GetInstance()->Truncate(context.get(),
                                                    Path(dfile2),
                                                    120));
-  ASSERT_EQ(1480, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1480, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -444,9 +394,7 @@ TEST_F(QuotaFileUtilTest, Remove) {
             QuotaFileUtil::GetInstance()->Delete(context.get(),
                                                  Path(file),
                                                  false));
-  ASSERT_EQ(1140, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(1140, GetCachedUsage());
 
   context.reset(NewContext());
   context->set_allowed_bytes_growth(QuotaFileUtil::kNoLimit);
@@ -454,9 +402,7 @@ TEST_F(QuotaFileUtilTest, Remove) {
             QuotaFileUtil::GetInstance()->Delete(context.get(),
                                                  Path(dir),
                                                  true));
-  ASSERT_EQ(0, test_helper().GetCachedOriginUsage());
-  ASSERT_EQ(test_helper().ComputeCurrentOriginUsage(),
-            test_helper().GetCachedOriginUsage());
+  ASSERT_EQ(0, GetCachedUsage());
 }
 
 }  // namespace fileapi