[Refactor] to rename and re-layer the file_util stack layers.

webkit/fileapi/native_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"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_test_helper.h"
-#include "webkit/fileapi/obfuscated_file_system_file_util.h"
+#include "webkit/fileapi/native_file_util.h"
+#include "webkit/fileapi/obfuscated_file_util.h"
 
 using namespace fileapi;
 
 namespace {
 
 struct CopyMoveTestCaseRecord {
   bool is_directory;
   const FilePath::CharType path[64];
   int64 data_file_size;
 };
@@ skipping 14 matching lines @@
   {false, FILE_PATH_LITERAL("file 3"), 0},
   {false, FILE_PATH_LITERAL("dir a/file 0"), 39},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 0"), 40},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 1"), 41},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 2"), 42},
   {false, FILE_PATH_LITERAL("dir a/dir d/dir e/dir g/file 3"), 50},
 };
 
 }  // namespace (anonymous)
 
-// This is not yet a full unit test for FileSystemFileUtil.  TODO(ericu): Adapt
+// This is not yet a full unit test for NativeFileUtil.  TODO(ericu): Adapt
 // the other subclasses' unit tests, as mentioned in the comments in
-// ObfuscatedFileSystemFileUtil's unit test.
+// ObfuscatedFileUtil's unit test.

[ericu, 2011/08/25 17:58:05]

This file should have stayed as file_system_file_util_unittest.cc; it's about
the superclass and its implementations, not about the native filesystem support.

Of course, we do still need unit tests for NativeFileUtil, and that's worth a
comment in NativeFileUtil.h or .cc.

[Dai Mikurube (NOT FULLTIME), 2011/08/26 05:10:59]

Ah, sure.  Done.

 // Currently this is just a test of cross-filesystem copy and move, which
-// actually exercises subclasses of FileSystemFileUtil as well as the class
+// actually exercises subclasses of NativeFileUtil as well as the class
 // itself.  We currently only test copies between obfuscated filesystems.
 // TODO(ericu): Add a test for copying between obfuscated and local filesystems,
 // and between different local filesystems.
-class FileSystemFileUtilTest : public testing::Test {
+class NativeFileUtilTest : public testing::Test {
  public:
-  FileSystemFileUtilTest() {
+  NativeFileUtilTest() {
   }
 
   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.
     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(
-        new ObfuscatedFileSystemFileUtil(base_dir.path(),
-                                         new FileSystemFileUtil()));
+    scoped_refptr<ObfuscatedFileUtil> file_util(
+        new ObfuscatedFileUtil(base_dir.path(), new NativeFileUtil()));
     FileSystemTestOriginHelper src_helper(src_origin, src_type);
     src_helper.SetUp(base_dir.path(),
                      false,  // incognito
                      false,  // unlimited quota
                      NULL,  // quota::QuotaManagerProxy
                      file_util.get());
     FileSystemTestOriginHelper dest_helper(dest_origin, dest_type);
     dest_helper.SetUp(src_helper.file_system_context(), NULL);
 
     // Set up all the source data.
@@ skipping 15 matching lines @@
         context.reset(NewContext(&src_helper));
         ASSERT_EQ(base::PLATFORM_FILE_OK, file_util->Truncate(
             context.get(), path, test_case.data_file_size));
       }
     }
 
     // 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_file_util(file_util);
+    copy_context->set_dest_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
@@ skipping 36 matching lines @@
         expected_result = base::PLATFORM_FILE_OK;
       else
         expected_result = base::PLATFORM_FILE_ERROR_NOT_FOUND;
       EXPECT_EQ(expected_result,
           file_util->GetFileInfo(
               context.get(), path, &src_file_info, &data_path));
     }
   }
 
  private:
-  DISALLOW_COPY_AND_ASSIGN(FileSystemFileUtilTest);
+  DISALLOW_COPY_AND_ASSIGN(NativeFileUtilTest);
 };
 
-TEST_F(FileSystemFileUtilTest, TestCrossFileSystemCopyDifferentOrigins) {
+TEST_F(NativeFileUtilTest, TestCrossFileSystemCopyDifferentOrigins) {
   GURL src_origin("http://www.example.com");
   fileapi::FileSystemType type = kFileSystemTypePersistent;
   GURL dest_origin("http://www.not.the.same.domain.com");
 
   TestCrossFileSystemCopyMoveHelper(src_origin, type, dest_origin, type, true);
 }
 
-TEST_F(FileSystemFileUtilTest, TestCrossFileSystemCopySameOrigin) {
+TEST_F(NativeFileUtilTest, TestCrossFileSystemCopySameOrigin) {
   GURL origin("http://www.example.com");
   fileapi::FileSystemType src_type = kFileSystemTypePersistent;
   fileapi::FileSystemType dest_type = kFileSystemTypeTemporary;
 
   TestCrossFileSystemCopyMoveHelper(origin, src_type, origin, dest_type, true);
 }
 
-TEST_F(FileSystemFileUtilTest, TestCrossFileSystemMoveDifferentOrigins) {
+TEST_F(NativeFileUtilTest, TestCrossFileSystemMoveDifferentOrigins) {
   GURL src_origin("http://www.example.com");
   fileapi::FileSystemType type = kFileSystemTypePersistent;
   GURL dest_origin("http://www.not.the.same.domain.com");
 
   TestCrossFileSystemCopyMoveHelper(src_origin, type, dest_origin, type, false);
 }
 
-TEST_F(FileSystemFileUtilTest, TestCrossFileSystemMoveSameOrigin) {
+TEST_F(NativeFileUtilTest, 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);
 }