Simplify directory path accounting.

webkit/fileapi/file_writer_delegate_unittest.cc

 // Copyright (c) 2011 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.
 //
 // NOTE: These tests are run as part of "unit_tests" (in chrome/test/unit)
 // rather than as part of test_shell_tests because they rely on being able
 // to instantiate a MessageLoop of type TYPE_IO.  test_shell_tests uses
 // TYPE_UI, which URLRequest doesn't allow.
 //
 
@@ skipping 231 matching lines @@
   context->set_allowed_bytes_growth(quota);
   return operation;
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
   PrepareForWrite(kBlobURL, 0, QuotaFileUtil::kNoLimit);
 
-  ASSERT_EQ(FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kDataSize + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  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());
 
   file_writer_delegate_.reset();
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   const GURL kBlobURL("blob:just");
   content_ = kData;
   const int64 kAllowedGrowth = kDataSize;
   PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
 
-  ASSERT_EQ(FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kAllowedGrowth + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
+  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   file_writer_delegate_.reset();
 
   EXPECT_EQ(kAllowedGrowth, 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);
 
-  ASSERT_EQ(FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kAllowedGrowth + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
+  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   file_writer_delegate_.reset();
 
   EXPECT_EQ(kAllowedGrowth, 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");
   content_ = "";
   int64 kAllowedGrowth = 0;
   PrepareForWrite(kBlobURL, 0, kAllowedGrowth);
 
-  ASSERT_EQ(FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kAllowedGrowth + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(kAllowedGrowth, test_helper_.GetCachedOriginUsage());
+  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   file_writer_delegate_.reset();
 
   EXPECT_EQ(kAllowedGrowth, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_TRUE(result_->complete());
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimitConcurrent) {
   scoped_ptr<FileWriterDelegate> file_writer_delegate2;
@@ skipping 19 matching lines @@
 
   PrepareForWrite(kBlobURL, 0, QuotaFileUtil::kNoLimit);
 
   // Credate another FileWriterDelegate for concurrent write.
   result2.reset(new Result());
   file_writer_delegate2.reset(new FileWriterDelegate(
       CreateNewOperation(result2.get(), QuotaFileUtil::kNoLimit),
       0, base::MessageLoopProxy::current()));
   request2.reset(new net::URLRequest(kBlobURL2, file_writer_delegate2.get()));
 
-  ASSERT_EQ(FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   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 + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(kDataSize * 2, test_helper_.GetCachedOriginUsage());
   base::FlushPlatformFile(file2);
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  EXPECT_EQ(ComputeCurrentOriginUsage(), test_helper_.GetCachedOriginUsage());
 
   file_writer_delegate_.reset();
 
   EXPECT_EQ(kDataSize, result_->bytes_written());
   EXPECT_EQ(base::PLATFORM_FILE_OK, result_->status());
   EXPECT_TRUE(result_->complete());
   EXPECT_EQ(kDataSize, 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(FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  ASSERT_EQ(0, test_helper_.GetCachedOriginUsage());
   file_writer_delegate_->Start(file_, request_.get());
   MessageLoop::current()->Run();
-  ASSERT_EQ(kDataSize + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  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 + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  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 + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  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 + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
+  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 +
-            FileSystemUsageCache::kUsageFileSize,
+  EXPECT_EQ(pre_write_usage + allowed_growth,
             test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
-            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;
 };
 
@@ skipping 10 matching lines @@
 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 + FileSystemUsageCache::kUsageFileSize,
-            test_helper_.GetCachedOriginUsage());
-  EXPECT_EQ(ComputeCurrentOriginUsage() + FileSystemUsageCache::kUsageFileSize,
+  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