Simplify directory path accounting.

webkit/fileapi/file_system_file_util_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.
 
 #include "base/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/scoped_temp_dir.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 46 matching lines @@
 class FileSystemFileUtilTest : public testing::Test {
  public:
   FileSystemFileUtilTest() {
   }
 
   void SetUp() {
   }
 
   FileSystemOperationContext* NewContext(FileSystemTestOriginHelper* helper) {
     FileSystemOperationContext* context = helper->NewOperationContext();
+    // We need to allocate quota for paths for
+    // TestCrossFileSystemCopyMoveHelper, since it calls into OFSFU, which
+    // charges quota for paths.

[Dai Mikurube (NOT FULLTIME), 2011/08/16 05:11:00]

Does this test require OFSFU?  Or could it be in OFSFUTest?

[ericu, 2011/08/16 21:16:31]

The cross-filesystem copy/move is a FSFU method.  It happens to call into OFSFU
in this case.  We could theoretically test it by copying from one LocalFSFU to
another, but given that they'd both really be looking at the same underlying OS
filesystem, I don't think we could trust the test quite as much.  There could be
bugs that would slip through.

+    context->set_allowed_bytes_growth(1024 * 1024);
     return context;
   }
 
   void TestCrossFileSystemCopyMoveHelper(
       const GURL& src_origin, fileapi::FileSystemType src_type,
       const GURL& dest_origin, fileapi::FileSystemType dest_type,
       bool copy) {
     ScopedTempDir base_dir;
     ASSERT_TRUE(base_dir.CreateUniqueTempDir());
     scoped_refptr<ObfuscatedFileSystemFileUtil> file_util(
@@ skipping 33 matching lines @@
     // Do the actual copy or move.
     FileSystemContext* file_system_context = dest_helper.file_system_context();
     scoped_ptr<FileSystemOperationContext> copy_context(
         new FileSystemOperationContext(file_system_context, NULL));
     copy_context->set_src_file_system_file_util(file_util);
     copy_context->set_dest_file_system_file_util(file_util);
     copy_context->set_src_origin_url(src_helper.origin());
     copy_context->set_dest_origin_url(dest_helper.origin());
     copy_context->set_src_type(src_helper.type());
     copy_context->set_dest_type(dest_helper.type());
+    copy_context->set_allowed_bytes_growth(1024 * 1024); // OFSFU path quota.
 
     if (copy)
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           file_util->Copy(copy_context.get(), test_root, test_root));
     else
       ASSERT_EQ(base::PLATFORM_FILE_OK,
           file_util->Move(copy_context.get(), test_root, test_root));
 
     // Validate that the destination paths are correct.
     for (size_t i = 0; i < arraysize(kCopyMoveTestCases); ++i) {
@@ skipping 65 matching lines @@
   TestCrossFileSystemCopyMoveHelper(src_origin, type, dest_origin, type, false);
 }
 
 TEST_F(FileSystemFileUtilTest, TestCrossFileSystemMoveSameOrigin) {
   GURL origin("http://www.example.com");
   fileapi::FileSystemType src_type = kFileSystemTypePersistent;
   fileapi::FileSystemType dest_type = kFileSystemTypeTemporary;
 
   TestCrossFileSystemCopyMoveHelper(origin, src_type, origin, dest_type, false);
 }