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

Splits FileSystemFileUtil into two classes.
1. FileSystemFileUtil (pure virtual and non-virtual functions + functions to forward to an underlying file_util.)
2. NativeFileUtil (FileUtil for OS-native operations)

Renames *FileSystemFileUtil into *FileUtil except for FileSystemFileUtil.

Renames *_file_system_file_util.{cc,h} into *_file_util.{cc,h}.

Renames variable *_file_system_file_util into *_file_util.

BUG=none
TEST=All FileAPI-related tests

Review URL: http://codereview.chromium.org/7470037
Patch from Dai Mikurube <dmikurube@chromium.org>.

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

39 files changed, 1939 insertions, 1679 deletions

diff --git a/webkit/chromeos/fileapi/cros_mount_point_provider.cc b/webkit/chromeos/fileapi/cros_mount_point_provider.cc
index 2aee434..55b574a 100644
--- a/webkit/chromeos/fileapi/cros_mount_point_provider.cc
+++ b/webkit/chromeos/fileapi/cros_mount_point_provider.cc
@@ -17,9 +17,9 @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFileSystem.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "webkit/chromeos/fileapi/file_access_permissions.h"
-#include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/native_file_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 namespace chromeos {
@@ -42,8 +42,8 @@ CrosMountPointProvider::CrosMountPointProvider(
     scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy)
     : special_storage_policy_(special_storage_policy),
       file_access_permissions_(new FileAccessPermissions()),
-      local_file_util_(new fileapi::LocalFileSystemFileUtil(
-          new fileapi::FileSystemFileUtil())) {
+      local_file_util_(
+          new fileapi::LocalFileUtil(new fileapi::NativeFileUtil())) {
   for (size_t i = 0; i < arraysize(fixed_exposed_paths); i++) {
     mount_point_map_.insert(std::pair<std::string, FilePath>(
         std::string(fixed_exposed_paths[i].web_root_path),
@@ -178,7 +178,7 @@ std::vector<FilePath> CrosMountPointProvider::GetRootDirectories() const {
   return root_dirs;
 }
 
-fileapi::FileSystemFileUtil* CrosMountPointProvider::GetFileSystemFileUtil() {
+fileapi::FileSystemFileUtil* CrosMountPointProvider::GetFileUtil() {
   return local_file_util_.get();
 }
 
diff --git a/webkit/chromeos/fileapi/cros_mount_point_provider.h b/webkit/chromeos/fileapi/cros_mount_point_provider.h
index af7a657..2144b2f 100644
--- a/webkit/chromeos/fileapi/cros_mount_point_provider.h
+++ b/webkit/chromeos/fileapi/cros_mount_point_provider.h
@@ -1,4 +1,4 @@
-  // Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -12,7 +12,7 @@
 #include "base/file_path.h"
 #include "base/synchronization/lock.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
 #include "webkit/quota/special_storage_policy.h"
 
 namespace fileapi {
@@ -47,7 +47,7 @@ class CrosMountPointProvider
       bool create);
   virtual bool IsRestrictedFileName(const FilePath& filename) const OVERRIDE;
   virtual std::vector<FilePath> GetRootDirectories() const OVERRIDE;
-  virtual fileapi::FileSystemFileUtil* GetFileSystemFileUtil() OVERRIDE;
+  virtual fileapi::FileSystemFileUtil* GetFileUtil() OVERRIDE;
 
   // fileapi::ExternalFileSystemMountPointProvider overrides.
   virtual void GrantFullAccessToExtension(
@@ -73,7 +73,7 @@ class CrosMountPointProvider
   MountPointMap mount_point_map_;
   scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
   scoped_ptr<FileAccessPermissions> file_access_permissions_;
-  scoped_ptr<fileapi::LocalFileSystemFileUtil> local_file_util_;
+  scoped_ptr<fileapi::LocalFileUtil> local_file_util_;
   DISALLOW_COPY_AND_ASSIGN(CrosMountPointProvider);
 };
 
diff --git a/webkit/fileapi/file_system_dir_url_request_job_unittest.cc b/webkit/fileapi/file_system_dir_url_request_job_unittest.cc
index 190caa9..991d33a 100644
--- a/webkit/fileapi/file_system_dir_url_request_job_unittest.cc
+++ b/webkit/fileapi/file_system_dir_url_request_job_unittest.cc
@@ -202,7 +202,7 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
 
   FileSystemFileUtil* file_util() {
     return file_system_context_->path_manager()->sandbox_provider()->
-        GetFileSystemFileUtil();
+        GetFileUtil();
   }
 
   // Put the message loop at the top, so that it's the last thing deleted.
diff --git a/webkit/fileapi/file_system_file_util.cc b/webkit/fileapi/file_system_file_util.cc
index 467c38e..5daa6a6 100644
--- a/webkit/fileapi/file_system_file_util.cc
+++ b/webkit/fileapi/file_system_file_util.cc
@@ -5,9 +5,7 @@
 #include "webkit/fileapi/file_system_file_util.h"
 
 #include <stack>
-#include <vector>
 
-#include "base/file_util_proxy.h"
 #include "base/memory/scoped_ptr.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 
@@ -28,133 +26,14 @@ bool ParentExists(FileSystemOperationContext* context,
 
 }  // namespace
 
-PlatformFileError FileSystemFileUtil::CreateOrOpen(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path, int file_flags,
-    PlatformFile* file_handle, bool* created) {
-  if (!file_util::DirectoryExists(file_path.DirName())) {
-    // If its parent does not exist, should return NOT_FOUND error.
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  }
-  PlatformFileError error_code = base::PLATFORM_FILE_OK;
-  *file_handle = base::CreatePlatformFile(file_path, file_flags,
-                                          created, &error_code);
-  return error_code;
-}
-
-PlatformFileError FileSystemFileUtil::Close(
-    FileSystemOperationContext* unused,
-    PlatformFile file_handle) {
-  if (!base::ClosePlatformFile(file_handle))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
-}
-
-PlatformFileError FileSystemFileUtil::EnsureFileExists(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path,
-    bool* created) {
-  if (!file_util::DirectoryExists(file_path.DirName()))
-    // If its parent does not exist, should return NOT_FOUND error.
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  PlatformFileError error_code = base::PLATFORM_FILE_OK;
-  // Tries to create the |file_path| exclusively.  This should fail
-  // with base::PLATFORM_FILE_ERROR_EXISTS if the path already exists.
-  PlatformFile handle = base::CreatePlatformFile(
-      file_path,
-      base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
-      created, &error_code);
-  if (error_code == base::PLATFORM_FILE_ERROR_EXISTS) {
-    // Make sure created_ is false.
-    if (created)
-      *created = false;
-    error_code = base::PLATFORM_FILE_OK;
-  }
-  if (handle != base::kInvalidPlatformFileValue)
-    base::ClosePlatformFile(handle);
-  return error_code;
-}
-
-PlatformFileError FileSystemFileUtil::GetLocalFilePath(
-    FileSystemOperationContext* context,
-    const FilePath& virtual_path,
-    FilePath* local_path) {
-  *local_path = virtual_path;
-  return base::PLATFORM_FILE_OK;
-}
-
-PlatformFileError FileSystemFileUtil::GetFileInfo(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path,
-    base::PlatformFileInfo* file_info,
-    FilePath* platform_file_path) {
-  if (!file_util::PathExists(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  // TODO(rkc): Fix this hack once we have refactored file_util to handle
-  // symlinks correctly.
-  // http://code.google.com/p/chromium-os/issues/detail?id=15948
-  if (file_util::IsLink(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  if (!file_util::GetFileInfo(file_path, file_info))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  *platform_file_path = file_path;
-  return base::PLATFORM_FILE_OK;
+FileSystemFileUtil::FileSystemFileUtil() {
 }
 
-PlatformFileError FileSystemFileUtil::ReadDirectory(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path,
-    std::vector<base::FileUtilProxy::Entry>* entries) {
-  // TODO(kkanetkar): Implement directory read in multiple chunks.
-  if (!file_util::DirectoryExists(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-
-  file_util::FileEnumerator file_enum(
-      file_path, false, static_cast<file_util::FileEnumerator::FileType>(
-      file_util::FileEnumerator::FILES |
-      file_util::FileEnumerator::DIRECTORIES));
-  FilePath current;
-  while (!(current = file_enum.Next()).empty()) {
-    base::FileUtilProxy::Entry entry;
-    file_util::FileEnumerator::FindInfo info;
-    file_enum.GetFindInfo(&info);
-    entry.is_directory = file_enum.IsDirectory(info);
-    // This will just give the entry's name instead of entire path
-    // if we use current.value().
-    entry.name = file_util::FileEnumerator::GetFilename(info).value();
-    entry.size = file_util::FileEnumerator::GetFilesize(info);
-    entry.last_modified_time =
-        file_util::FileEnumerator::GetLastModifiedTime(info);
-    // TODO(rkc): Fix this also once we've refactored file_util
-    // http://code.google.com/p/chromium-os/issues/detail?id=15948
-    // This currently just prevents a file from showing up at all
-    // if it's a link, hence preventing arbitary 'read' exploits.
-    if (!file_util::IsLink(file_path.Append(entry.name)))
-      entries->push_back(entry);
-  }
-  return base::PLATFORM_FILE_OK;
+FileSystemFileUtil::FileSystemFileUtil(FileSystemFileUtil* underlying_file_util)
+    : underlying_file_util_(underlying_file_util) {
 }
 
-PlatformFileError FileSystemFileUtil::CreateDirectory(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path,
-    bool exclusive,
-    bool recursive) {
-  // If parent dir of file doesn't exist.
-  if (!recursive && !file_util::PathExists(file_path.DirName()))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-
-  bool path_exists = file_util::PathExists(file_path);
-  if (exclusive && path_exists)
-    return base::PLATFORM_FILE_ERROR_EXISTS;
-
-  // If file exists at the path.
-  if (path_exists && !file_util::DirectoryExists(file_path))
-    return base::PLATFORM_FILE_ERROR_EXISTS;
-
-  if (!file_util::CreateDirectory(file_path))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+FileSystemFileUtil::~FileSystemFileUtil() {
 }
 
 PlatformFileError FileSystemFileUtil::Copy(
@@ -208,36 +87,214 @@ PlatformFileError FileSystemFileUtil::Delete(
   }
 }
 
+PlatformFileError FileSystemFileUtil::CreateOrOpen(
+    FileSystemOperationContext* context,
+    const FilePath& file_path, int file_flags,
+    PlatformFile* file_handle, bool* created) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->CreateOrOpen(
+        context, file_path, file_flags, file_handle, created);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::Close(
+    FileSystemOperationContext* context,
+    PlatformFile file_handle) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->Close(context, file_handle);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::EnsureFileExists(
+    FileSystemOperationContext* context,
+    const FilePath& file_path,
+    bool* created) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->EnsureFileExists(context, file_path, created);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::CreateDirectory(
+    FileSystemOperationContext* context,
+    const FilePath& file_path,
+    bool exclusive,
+    bool recursive) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->CreateDirectory(
+        context, file_path, exclusive, recursive);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::GetFileInfo(
+    FileSystemOperationContext* context,
+    const FilePath& file_path,
+    base::PlatformFileInfo* file_info,
+    FilePath* platform_file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->GetFileInfo(
+        context, file_path, file_info, platform_file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::ReadDirectory(
+    FileSystemOperationContext* context,
+    const FilePath& file_path,
+    std::vector<base::FileUtilProxy::Entry>* entries) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->ReadDirectory(context, file_path, entries);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+FileSystemFileUtil::AbstractFileEnumerator*
+FileSystemFileUtil::CreateFileEnumerator(
+    FileSystemOperationContext* context,
+    const FilePath& root_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->CreateFileEnumerator(context, root_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return NULL;
+}
+
+PlatformFileError FileSystemFileUtil::GetLocalFilePath(
+    FileSystemOperationContext* context,
+    const FilePath& virtual_path,
+    FilePath* local_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->GetLocalFilePath(
+        context, virtual_path, local_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
 PlatformFileError FileSystemFileUtil::Touch(
-    FileSystemOperationContext* unused,
+    FileSystemOperationContext* context,
     const FilePath& file_path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
-  if (!file_util::TouchFile(
-          file_path, last_access_time, last_modified_time))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->Touch(
+        context, file_path, last_access_time, last_modified_time);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 PlatformFileError FileSystemFileUtil::Truncate(
-    FileSystemOperationContext* unused,
+    FileSystemOperationContext* context,
     const FilePath& file_path,
     int64 length) {
-  PlatformFileError error_code(base::PLATFORM_FILE_ERROR_FAILED);
-  PlatformFile file =
-      base::CreatePlatformFile(
-          file_path,
-          base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
-          NULL,
-          &error_code);
-  if (error_code != base::PLATFORM_FILE_OK) {
-    return error_code;
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->Truncate(context, file_path, length);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+
+bool FileSystemFileUtil::PathExists(
+    FileSystemOperationContext* context,
+    const FilePath& file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->PathExists(context, file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return false;
+}
+
+bool FileSystemFileUtil::DirectoryExists(
+    FileSystemOperationContext* context,
+    const FilePath& file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->DirectoryExists(context, file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return false;
+}
+
+bool FileSystemFileUtil::IsDirectoryEmpty(
+    FileSystemOperationContext* context,
+    const FilePath& file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->IsDirectoryEmpty(context, file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return false;
+}
+
+PlatformFileError FileSystemFileUtil::CopyOrMoveFile(
+    FileSystemOperationContext* context,
+    const FilePath& src_file_path,
+    const FilePath& dest_file_path,
+    bool copy) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->CopyOrMoveFile(
+        context, src_file_path, dest_file_path, copy);
   }
-  DCHECK_NE(base::kInvalidPlatformFileValue, file);
-  if (!base::TruncatePlatformFile(file, length))
-    error_code = base::PLATFORM_FILE_ERROR_FAILED;
-  base::ClosePlatformFile(file);
-  return error_code;
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::CopyInForeignFile(
+      FileSystemOperationContext* context,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->CopyInForeignFile(
+        context, src_file_path, dest_file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::DeleteFile(
+    FileSystemOperationContext* context,
+    const FilePath& file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->DeleteFile(context, file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError FileSystemFileUtil::DeleteSingleDirectory(
+    FileSystemOperationContext* context,
+    const FilePath& file_path) {
+  if (underlying_file_util_.get()) {
+    return underlying_file_util_->DeleteSingleDirectory(context, file_path);
+  }
+  NOTREACHED() << "Subclasses must provide implementation if they have no"
+               << "underlying_file_util";
+  return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 PlatformFileError
@@ -248,14 +305,13 @@ FileSystemFileUtil::PerformCommonCheckAndPreparationForMoveAndCopy(
   bool same_file_system =
      (context->src_origin_url() == context->dest_origin_url()) &&
      (context->src_type() == context->dest_type());
-  FileSystemFileUtil* dest_util = context->dest_file_system_file_util();
+  FileSystemFileUtil* dest_util = context->dest_file_util();
   DCHECK(dest_util);
   scoped_ptr<FileSystemOperationContext> local_dest_context;
   FileSystemOperationContext* dest_context = NULL;
   if (same_file_system) {
     dest_context = context;
-    DCHECK(context->src_file_system_file_util() ==
-         context->dest_file_system_file_util());
+    DCHECK(context->src_file_util() == context->dest_file_util());
   } else {
     local_dest_context.reset(context->CreateInheritedContextForDest());
     // All the single-path virtual FSFU methods expect the context information
@@ -317,35 +373,12 @@ FileSystemFileUtil::PerformCommonCheckAndPreparationForMoveAndCopy(
   return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError FileSystemFileUtil::CopyOrMoveFile(
-      FileSystemOperationContext* unused,
-      const FilePath& src_file_path,
-      const FilePath& dest_file_path,
-      bool copy) {
-  if (copy) {
-    if (file_util::CopyFile(src_file_path, dest_file_path))
-      return base::PLATFORM_FILE_OK;
-  } else {
-    DCHECK(!file_util::DirectoryExists(src_file_path));
-    if (file_util::Move(src_file_path, dest_file_path))
-      return base::PLATFORM_FILE_OK;
-  }
-  return base::PLATFORM_FILE_ERROR_FAILED;
-}
-
-PlatformFileError FileSystemFileUtil::CopyInForeignFile(
-      FileSystemOperationContext* context,
-      const FilePath& src_file_path,
-      const FilePath& dest_file_path) {
-  return CopyOrMoveFile(context, src_file_path, dest_file_path, true);
-}
-
 PlatformFileError FileSystemFileUtil::CopyOrMoveDirectory(
       FileSystemOperationContext* context,
       const FilePath& src_file_path,
       const FilePath& dest_file_path,
       bool copy) {
-  FileSystemFileUtil* dest_util = context->dest_file_system_file_util();
+  FileSystemFileUtil* dest_util = context->dest_file_util();
   // All the single-path virtual FSFU methods expect the context information to
   // be in the src_* variables, not the dest_* variables, so we have to make a
   // new context if we want to call them on the dest_file_path.
@@ -408,8 +441,7 @@ PlatformFileError FileSystemFileUtil::CopyOrMoveFileHelper(
   // CopyOrMoveFile here is the virtual overridden member function.
   if ((context->src_origin_url() == context->dest_origin_url()) &&
       (context->src_type() == context->dest_type())) {
-    DCHECK(context->src_file_system_file_util() ==
-           context->dest_file_system_file_util());
+    DCHECK(context->src_file_util() == context->dest_file_util());
     return CopyOrMoveFile(context, src_file_path, dest_file_path, copy);
   }
   base::PlatformFileInfo file_info;
@@ -420,45 +452,14 @@ PlatformFileError FileSystemFileUtil::CopyOrMoveFileHelper(
   if (error_code != base::PLATFORM_FILE_OK)
     return error_code;
 
-  DCHECK(context->dest_file_system_file_util());
-  error_code = context->dest_file_system_file_util()->CopyInForeignFile(
+  DCHECK(context->dest_file_util());
+  error_code = context->dest_file_util()->CopyInForeignFile(
       context, platform_file_path, dest_file_path);
   if (copy || error_code != base::PLATFORM_FILE_OK)
     return error_code;
   return DeleteFile(context, src_file_path);
 }
 
-
-PlatformFileError FileSystemFileUtil::DeleteFile(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path) {
-  if (!file_util::PathExists(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  if (file_util::DirectoryExists(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
-  if (!file_util::Delete(file_path, false))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
-}
-
-PlatformFileError FileSystemFileUtil::DeleteSingleDirectory(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path) {
-  if (!file_util::PathExists(file_path))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  if (!file_util::DirectoryExists(file_path)) {
-    // TODO(dmikurube): Check if this error code is appropriate.
-    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
-  }
-  if (!file_util::IsDirectoryEmpty(file_path)) {
-    // TODO(dmikurube): Check if this error code is appropriate.
-    return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
-  }
-  if (!file_util::Delete(file_path, false))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  return base::PLATFORM_FILE_OK;
-}
-
 PlatformFileError FileSystemFileUtil::DeleteDirectoryRecursive(
     FileSystemOperationContext* context,
     const FilePath& file_path) {
@@ -491,67 +492,4 @@ PlatformFileError FileSystemFileUtil::DeleteDirectoryRecursive(
   return DeleteSingleDirectory(context, file_path);
 }
 
-bool FileSystemFileUtil::PathExists(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path) {
-  return file_util::PathExists(file_path);
-}
-
-bool FileSystemFileUtil::DirectoryExists(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path) {
-  return file_util::DirectoryExists(file_path);
-}
-
-bool FileSystemFileUtil::IsDirectoryEmpty(
-    FileSystemOperationContext* unused,
-    const FilePath& file_path) {
-  return file_util::IsDirectoryEmpty(file_path);
-}
-
-class FileSystemFileEnumerator
-    : public FileSystemFileUtil::AbstractFileEnumerator {
- public:
-  FileSystemFileEnumerator(const FilePath& root_path,
-                           bool recursive,
-                           file_util::FileEnumerator::FileType file_type)
-    : file_enum_(root_path, recursive, file_type) {
-  }
-
-  ~FileSystemFileEnumerator() {}
-
-  virtual FilePath Next() OVERRIDE;
-  virtual int64 Size() OVERRIDE;
-  virtual bool IsDirectory() OVERRIDE;
-
- private:
-  file_util::FileEnumerator file_enum_;
-  file_util::FileEnumerator::FindInfo file_util_info_;
-};
-
-FilePath FileSystemFileEnumerator::Next() {
-  FilePath rv = file_enum_.Next();
-  if (!rv.empty())
-    file_enum_.GetFindInfo(&file_util_info_);
-  return rv;
-}
-
-int64 FileSystemFileEnumerator::Size() {
-  return file_util::FileEnumerator::GetFilesize(file_util_info_);
-}
-
-bool FileSystemFileEnumerator::IsDirectory() {
-  return file_util::FileEnumerator::IsDirectory(file_util_info_);
-}
-
-FileSystemFileUtil::AbstractFileEnumerator*
-FileSystemFileUtil::CreateFileEnumerator(
-    FileSystemOperationContext* unused,
-    const FilePath& root_path) {
-  return new FileSystemFileEnumerator(
-      root_path, true, static_cast<file_util::FileEnumerator::FileType>(
-      file_util::FileEnumerator::FILES |
-      file_util::FileEnumerator::DIRECTORIES));
-}
-
 }  // namespace fileapi
diff --git a/webkit/fileapi/file_system_file_util.h b/webkit/fileapi/file_system_file_util.h
index 8372784..83a04c8 100644
--- a/webkit/fileapi/file_system_file_util.h
+++ b/webkit/fileapi/file_system_file_util.h
@@ -5,20 +5,11 @@
 #ifndef WEBKIT_FILEAPI_FILE_SYSTEM_FILE_UTIL_H_
 #define WEBKIT_FILEAPI_FILE_SYSTEM_FILE_UTIL_H_
 
-#include <vector>
-
-#include "base/callback.h"
 #include "base/file_path.h"
-#include "base/file_util.h"
 #include "base/file_util_proxy.h"
-#include "base/memory/ref_counted.h"
 #include "base/platform_file.h"
-#include "base/tracked_objects.h"
-#include "webkit/fileapi/file_system_types.h"
 
 namespace base {
-struct PlatformFileInfo;
-class MessageLoopProxy;
 class Time;
 }
 
@@ -48,84 +39,27 @@ class FileSystemOperationContext;
 //  PerformCommonCheckAndPreparationForMoveAndCopy and CopyOrMoveDirectory.
 class FileSystemFileUtil {
  public:
-  FileSystemFileUtil() {}
-  virtual ~FileSystemFileUtil() {}
-
-  // Creates or opens a file with the given flags.  It is invalid to pass NULL
-  // for the callback.
-  // If PLATFORM_FILE_CREATE is set in |file_flags| it always tries to create
-  // a new file at the given |file_path| and calls back with
-  // PLATFORM_FILE_ERROR_FILE_EXISTS if the |file_path| already exists.
-  virtual PlatformFileError CreateOrOpen(
-      FileSystemOperationContext* context,
-      const FilePath& file_path,
-      int file_flags,
-      PlatformFile* file_handle,
-      bool* created);
-
-  // Close the given file handle.
-  virtual PlatformFileError Close(
-      FileSystemOperationContext* context,
-      PlatformFile);
-
-  // Ensures that the given |file_path| exist.  This creates a empty new file
-  // at |file_path| if the |file_path| does not exist.
-  // If a new file han not existed and is created at the |file_path|,
-  // |created| of the callback argument is set true and |error code|
-  // is set PLATFORM_FILE_OK.
-  // If the file already exists, |created| is set false and |error code|
-  // is set PLATFORM_FILE_OK.
-  // If the file hasn't existed but it couldn't be created for some other
-  // reasons, |created| is set false and |error code| indicates the error.
-  virtual PlatformFileError EnsureFileExists(
-      FileSystemOperationContext* context,
-      const FilePath& file_path, bool* created);
+  // It will be implemented by each subclass such as FileSystemFileEnumerator.
+  class AbstractFileEnumerator {
+   public:
+    virtual ~AbstractFileEnumerator() {}
 
-  // Maps |virtual_path| given |context| into |local_path| which represents
-  // physical file location on the host OS. This may not always make sense for
-  // all subclasses.
-  virtual PlatformFileError GetLocalFilePath(
-      FileSystemOperationContext* context,
-      const FilePath& virtual_path,
-      FilePath* local_path);
+    // Returns an empty string if there are no more results.
+    virtual FilePath Next() = 0;
 
-  // Retrieves the information about a file.  It is invalid to pass NULL for the
-  // callback.
-  virtual PlatformFileError GetFileInfo(
-      FileSystemOperationContext* context,
-      const FilePath& file_,
-      base::PlatformFileInfo* file_info,
-      FilePath* platform_path);
+    virtual int64 Size() = 0;
+    virtual bool IsDirectory() = 0;
+  };
 
-  // Reads the filenames in |file_path|.
-  virtual PlatformFileError ReadDirectory(
-      FileSystemOperationContext* context,
-      const FilePath& file_path,
-      std::vector<base::FileUtilProxy::Entry>* entries);
+  class EmptyFileEnumerator : public AbstractFileEnumerator {
+    virtual FilePath Next() OVERRIDE { return FilePath(); }
+    virtual int64 Size() OVERRIDE { return 0; }
+    virtual bool IsDirectory() OVERRIDE { return false; }
+  };
 
-  // Creates directory at given path. It's an error to create
-  // if |exclusive| is true and dir already exists.
-  virtual PlatformFileError CreateDirectory(
-      FileSystemOperationContext* context,
-      const FilePath& file_path,
-      bool exclusive,
-      bool recursive);
+  virtual ~FileSystemFileUtil();
 
   // Copies or moves a single file.
-  virtual PlatformFileError CopyOrMoveFile(
-      FileSystemOperationContext* context,
-      const FilePath& src_file_path,
-      const FilePath& dest_file_path,
-      bool copy);
-
-  // Copies in a single file from a different filesystem.  The src_file_path is
-  // a true local platform path, regardless of which subclass of
-  // FileSystemFileUtil is being invoked.
-  virtual PlatformFileError CopyInForeignFile(
-        FileSystemOperationContext* context,
-        const FilePath& src_file_path,
-        const FilePath& dest_file_path);
-
   // Copies a file or a directory from |src_file_path| to |dest_file_path|.
   //
   // Error cases:
@@ -171,23 +105,76 @@ class FileSystemFileUtil {
       const FilePath& file_path,
       bool recursive);
 
-  // Deletes a single file.
-  // It assumes the given path points a file.
-  //
-  // This method is called from DeleteDirectoryRecursive and Delete (both are
-  // non-virtual).
-  virtual PlatformFileError DeleteFile(
-      FileSystemOperationContext* unused,
-      const FilePath& file_path);
+  // Creates or opens a file with the given flags.  It is invalid to pass NULL
+  // for the callback.
+  // If PLATFORM_FILE_CREATE is set in |file_flags| it always tries to create
+  // a new file at the given |file_path| and calls back with
+  // PLATFORM_FILE_ERROR_FILE_EXISTS if the |file_path| already exists.
+  virtual PlatformFileError CreateOrOpen(
+      FileSystemOperationContext* context,
+      const FilePath& file_path,
+      int file_flags,
+      PlatformFile* file_handle,
+      bool* created);
 
-  // Deletes a single empty directory.
-  // It assumes the given path points an empty directory.
+  // Close the given file handle.
+  virtual PlatformFileError Close(
+      FileSystemOperationContext* context,
+      PlatformFile);
+
+  // Ensures that the given |file_path| exist.  This creates a empty new file
+  // at |file_path| if the |file_path| does not exist.
+  // If a new file han not existed and is created at the |file_path|,
+  // |created| of the callback argument is set true and |error code|
+  // is set PLATFORM_FILE_OK.
+  // If the file already exists, |created| is set false and |error code|
+  // is set PLATFORM_FILE_OK.
+  // If the file hasn't existed but it couldn't be created for some other
+  // reasons, |created| is set false and |error code| indicates the error.
+  virtual PlatformFileError EnsureFileExists(
+      FileSystemOperationContext* context,
+      const FilePath& file_path, bool* created);
+
+  // Creates directory at given path. It's an error to create
+  // if |exclusive| is true and dir already exists.
+  virtual PlatformFileError CreateDirectory(
+      FileSystemOperationContext* context,
+      const FilePath& file_path,
+      bool exclusive,
+      bool recursive);
+
+  // Retrieves the information about a file.  It is invalid to pass NULL for the
+  // callback.
+  virtual PlatformFileError GetFileInfo(
+      FileSystemOperationContext* context,
+      const FilePath& file_,
+      base::PlatformFileInfo* file_info,
+      FilePath* platform_path);
+
+  // Reads the filenames in |file_path|.
+  virtual PlatformFileError ReadDirectory(
+      FileSystemOperationContext* context,
+      const FilePath& file_path,
+      std::vector<base::FileUtilProxy::Entry>* entries);
+
+  // Returns a pointer to a new instance of AbstractFileEnumerator which is
+  // implemented for each FileSystemFileUtil subclass. The instance needs to be
+  // freed by the caller, and its lifetime should not extend past when the
+  // current call returns to the main FILE message loop.
   //
-  // This method is called from DeleteDirectoryRecursive and Delete (both are
-  // non-virtual).
-  virtual PlatformFileError DeleteSingleDirectory(
-      FileSystemOperationContext* unused,
-      const FilePath& file_path);
+  // The supplied context must remain valid at least lifetime of the enumerator
+  // instance.
+  virtual AbstractFileEnumerator* CreateFileEnumerator(
+      FileSystemOperationContext* context,
+      const FilePath& root_path);
+
+  // Maps |virtual_path| given |context| into |local_path| which represents
+  // physical file location on the host OS. This may not always make sense for
+  // all subclasses.
+  virtual PlatformFileError GetLocalFilePath(
+      FileSystemOperationContext* context,
+      const FilePath& virtual_path,
+      FilePath* local_path);
 
   // Touches a file. The callback can be NULL.
   // If the file doesn't exist, this fails with PLATFORM_FILE_ERROR_NOT_FOUND.
@@ -206,63 +193,58 @@ class FileSystemFileUtil {
       int64 length);
 
   virtual bool PathExists(
-      FileSystemOperationContext* unused,
+      FileSystemOperationContext* context,
       const FilePath& file_path);
 
   virtual bool DirectoryExists(
-      FileSystemOperationContext* unused,
+      FileSystemOperationContext* context,
       const FilePath& file_path);
 
   virtual bool IsDirectoryEmpty(
-      FileSystemOperationContext* unused,
+      FileSystemOperationContext* context,
       const FilePath& file_path);
 
-  // It will be implemented by each subclass such as FileSystemFileEnumerator.
-  class AbstractFileEnumerator {
-   public:
-    virtual ~AbstractFileEnumerator() {}
-
-    // Returns an empty string if there are no more results.
-    virtual FilePath Next() = 0;
-
-    virtual int64 Size() = 0;
-    virtual bool IsDirectory() = 0;
-  };
+  virtual PlatformFileError CopyOrMoveFile(
+      FileSystemOperationContext* context,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path,
+      bool copy);
 
-  class EmptyFileEnumerator : public AbstractFileEnumerator {
-    virtual FilePath Next() OVERRIDE { return FilePath(); }
-    virtual int64 Size() OVERRIDE { return 0; }
-    virtual bool IsDirectory() OVERRIDE { return false; }
-  };
+  // Copies in a single file from a different filesystem.  The src_file_path is
+  // a true local platform path, regardless of which subclass of
+  // FileSystemFileUtil is being invoked.
+  virtual PlatformFileError CopyInForeignFile(
+        FileSystemOperationContext* context,
+        const FilePath& src_file_path,
+        const FilePath& dest_file_path);
 
-  // Returns a pointer to a new instance of AbstractFileEnumerator which is
-  // implemented for each FileUtil subclass. The instance needs to be freed
-  // by the caller, and its lifetime should not extend past when the current
-  // call returns to the main FILE message loop.
+  // Deletes a single file.
+  // It assumes the given path points a file.
   //
-  // The supplied context must remain valid at least lifetime of the enumerator
-  // instance.
-  virtual AbstractFileEnumerator* CreateFileEnumerator(
+  // This method is called from DeleteDirectoryRecursive and Delete (both are
+  // non-virtual).
+  virtual PlatformFileError DeleteFile(
       FileSystemOperationContext* context,
-      const FilePath& root_path);
+      const FilePath& file_path);
 
- protected:
-  // Deletes a directory and all entries under the directory.
+  // Deletes a single empty directory.
+  // It assumes the given path points an empty directory.
   //
-  // This method is called from Delete.  It internally calls two following
-  // virtual methods,
-  // - (virtual) DeleteFile to delete files, and
-  // - (virtual) DeleteSingleDirectory to delete empty directories after all
-  // the files are deleted.
-  PlatformFileError DeleteDirectoryRecursive(
+  // This method is called from DeleteDirectoryRecursive and Delete (both are
+  // non-virtual).
+  virtual PlatformFileError DeleteSingleDirectory(
       FileSystemOperationContext* context,
       const FilePath& file_path);
 
+ protected:
+  FileSystemFileUtil();
+  explicit FileSystemFileUtil(FileSystemFileUtil* underlying_file_util);
+
   // This also removes the destination directory if it's non-empty and all
   // other checks are passed (so that the copy/move correctly overwrites the
   // destination).
   PlatformFileError PerformCommonCheckAndPreparationForMoveAndCopy(
-      FileSystemOperationContext* unused,
+      FileSystemOperationContext* context,
       const FilePath& src_file_path,
       const FilePath& dest_file_path);
 
@@ -286,6 +268,24 @@ class FileSystemFileUtil {
       const FilePath& dest_file_path,
       bool copy);
 
+  // Deletes a directory and all entries under the directory.
+  //
+  // This method is called from Delete.  It internally calls two following
+  // virtual methods,
+  // - (virtual) DeleteFile to delete files, and
+  // - (virtual) DeleteSingleDirectory to delete empty directories after all
+  // the files are deleted.
+  PlatformFileError DeleteDirectoryRecursive(
+      FileSystemOperationContext* context,
+      const FilePath& file_path);
+
+  FileSystemFileUtil* underlying_file_util() const {
+    return underlying_file_util_.get();
+  }
+
+ private:
+  scoped_ptr<FileSystemFileUtil> underlying_file_util_;
+
   DISALLOW_COPY_AND_ASSIGN(FileSystemFileUtil);
 };
 
diff --git a/webkit/fileapi/file_system_file_util_proxy.cc b/webkit/fileapi/file_system_file_util_proxy.cc
index 162a927..1906258 100644
--- a/webkit/fileapi/file_system_file_util_proxy.cc
+++ b/webkit/fileapi/file_system_file_util_proxy.cc
@@ -21,7 +21,7 @@ class MessageLoopRelay
             base::MessageLoopProxy::current()),
         error_code_(base::PLATFORM_FILE_OK),
         context_(context),
-        file_system_file_util_(NULL) {
+        file_util_(NULL) {
   }
 
   bool Start(scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
@@ -53,9 +53,9 @@ class MessageLoopRelay
     return &context_;
   }
 
-  fileapi::FileSystemFileUtil* file_system_file_util() const {
+  fileapi::FileSystemFileUtil* file_util() const {
     // TODO(ericu): Support calls that have two different FSFU subclasses.
-    return context_.src_file_system_file_util();
+    return context_.src_file_util();
   }
 
  private:
@@ -69,7 +69,7 @@ class MessageLoopRelay
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   base::PlatformFileError error_code_;
   fileapi::FileSystemOperationContext context_;
-  fileapi::FileSystemFileUtil* file_system_file_util_;
+  fileapi::FileSystemFileUtil* file_util_;
 };
 
 class RelayCreateOrOpen : public MessageLoopRelay {
@@ -98,9 +98,8 @@ class RelayCreateOrOpen : public MessageLoopRelay {
   }
 
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->CreateOrOpen(
-            context(), file_path_, file_flags_, &file_handle_, &created_));
+    set_error_code(file_util()->CreateOrOpen(
+        context(), file_path_, file_flags_, &file_handle_, &created_));
   }
 
   virtual void RunCallback() {
@@ -152,8 +151,7 @@ class RelayClose : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Close(context(), file_handle_));
+    set_error_code(file_util()->Close(context(), file_handle_));
   }
 
  private:
@@ -177,9 +175,8 @@ class RelayEnsureFileExists : public MessageLoopRelay {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->EnsureFileExists(
-            context(), file_path_, &created_));
+    set_error_code(file_util()->EnsureFileExists(
+        context(), file_path_, &created_));
   }
 
   virtual void RunCallback() {
@@ -209,9 +206,8 @@ class RelayGetLocalPath : public MessageLoopRelay {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->GetLocalFilePath(
-            context(), virtual_path_, &local_path_));
+    set_error_code(file_util()->GetLocalFilePath(
+        context(), virtual_path_, &local_path_));
   }
 
   virtual void RunCallback() {
@@ -239,9 +235,8 @@ class RelayGetFileInfo : public MessageLoopRelay {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->GetFileInfo(
-            context(), file_path_, &file_info_, &platform_path_));
+    set_error_code(file_util()->GetFileInfo(
+        context(), file_path_, &file_info_, &platform_path_));
   }
 
   virtual void RunCallback() {
@@ -270,9 +265,8 @@ class RelayReadDirectory : public MessageLoopRelay {
  protected:
   virtual void RunWork() {
     // TODO(kkanetkar): Implement directory read in multiple chunks.
-    set_error_code(
-        file_system_file_util()->ReadDirectory(
-            context(), file_path_, &entries_));
+    set_error_code(file_util()->ReadDirectory(
+        context(), file_path_, &entries_));
   }
 
   virtual void RunCallback() {
@@ -302,9 +296,8 @@ class RelayCreateDirectory : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->CreateDirectory(
-            context(), file_path_, exclusive_, recursive_));
+    set_error_code(file_util()->CreateDirectory(
+        context(), file_path_, exclusive_, recursive_));
   }
 
  private:
@@ -326,9 +319,8 @@ class RelayCopy : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Copy(
-            context(), src_file_path_, dest_file_path_));
+    set_error_code(file_util()->Copy(
+        context(), src_file_path_, dest_file_path_));
   }
 
  private:
@@ -349,9 +341,8 @@ class RelayMove : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Move(
-            context(), src_file_path_, dest_file_path_));
+    set_error_code(file_util()->Move(
+        context(), src_file_path_, dest_file_path_));
   }
 
  private:
@@ -372,9 +363,7 @@ class RelayDelete : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Delete(
-            context(), file_path_, recursive_));
+    set_error_code(file_util()->Delete(context(), file_path_, recursive_));
   }
 
  private:
@@ -397,9 +386,8 @@ class RelayTouchFilePath : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Touch(
-            context(), file_path_, last_access_time_, last_modified_time_));
+    set_error_code(file_util()->Touch(
+        context(), file_path_, last_access_time_, last_modified_time_));
   }
 
  private:
@@ -421,8 +409,7 @@ class RelayTruncate : public RelayWithStatusCallback {
 
  protected:
   virtual void RunWork() {
-    set_error_code(
-        file_system_file_util()->Truncate(context(), file_path_, length_));
+    set_error_code(file_util()->Truncate(context(), file_path_, length_));
   }
 
  private:
diff --git a/webkit/fileapi/file_system_file_util_unittest.cc b/webkit/fileapi/file_system_file_util_unittest.cc
index 459a19c..8837cfa 100644
--- a/webkit/fileapi/file_system_file_util_unittest.cc
+++ b/webkit/fileapi/file_system_file_util_unittest.cc
@@ -11,7 +11,8 @@
 #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;
 
@@ -48,7 +49,7 @@ const CopyMoveTestCaseRecord kCopyMoveTestCases[] = {
 
 // This is not yet a full unit test for FileSystemFileUtil.  TODO(ericu): Adapt
 // the other subclasses' unit tests, as mentioned in the comments in
-// ObfuscatedFileSystemFileUtil's unit test.
+// ObfuscatedFileUtil's unit test.
 // Currently this is just a test of cross-filesystem copy and move, which
 // actually exercises subclasses of FileSystemFileUtil as well as the class
 // itself.  We currently only test copies between obfuscated filesystems.
@@ -77,9 +78,8 @@ class FileSystemFileUtilTest : public testing::Test {
       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
@@ -115,8 +115,8 @@ class FileSystemFileUtilTest : public testing::Test {
     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());
diff --git a/webkit/fileapi/file_system_mount_point_provider.h b/webkit/fileapi/file_system_mount_point_provider.h
index bb42649..55161c3 100644
--- a/webkit/fileapi/file_system_mount_point_provider.h
+++ b/webkit/fileapi/file_system_mount_point_provider.h
@@ -52,7 +52,7 @@ class FileSystemMountPointProvider {
   // permissions.
   virtual std::vector<FilePath> GetRootDirectories() const = 0;
 
-  virtual FileSystemFileUtil* GetFileSystemFileUtil() = 0;
+  virtual FileSystemFileUtil* GetFileUtil() = 0;
 };
 
 // An interface to control external file system access permissions.
diff --git a/webkit/fileapi/file_system_operation.cc b/webkit/fileapi/file_system_operation.cc
index cd829b1..070d8540 100644
--- a/webkit/fileapi/file_system_operation.cc
+++ b/webkit/fileapi/file_system_operation.cc
@@ -17,7 +17,7 @@
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/file_writer_delegate.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_types.h"
 
@@ -60,11 +60,10 @@ FileSystemOperation::FileSystemOperation(
     FileSystemCallbackDispatcher* dispatcher,
     scoped_refptr<base::MessageLoopProxy> proxy,
     FileSystemContext* file_system_context,
-    FileSystemFileUtil* file_system_file_util)
+    FileSystemFileUtil* file_util)
     : proxy_(proxy),
       dispatcher_(dispatcher),
-      file_system_operation_context_(
-          file_system_context, file_system_file_util),
+      file_system_operation_context_(file_system_context, file_util),
       callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(dispatcher);
 #ifndef NDEBUG
@@ -109,18 +108,16 @@ void FileSystemOperation::CreateFile(const GURL& path,
 #endif
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
-  if (!VerifyFileSystemPathForWrite(
-      path, true /* create */, &origin_url, &type, &src_virtual_path_,
-      &file_system_file_util)) {
+  FileSystemFileUtil* file_util;
+  if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
+      &type, &src_virtual_path_, &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   exclusive_ = exclusive;
 
   GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
@@ -161,19 +158,17 @@ void FileSystemOperation::CreateDirectory(const GURL& path,
 #endif
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
 
-  if (!VerifyFileSystemPathForWrite(
-      path, true /* create */, &origin_url, &type, &src_virtual_path_,
-      &file_system_file_util)) {
+  if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
+      &type, &src_virtual_path_, &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   exclusive_ = exclusive;
   recursive_ = recursive;
 
@@ -217,14 +212,13 @@ void FileSystemOperation::Copy(const GURL& src_path,
   GURL dest_origin_url;
   FileSystemType src_type;
   FileSystemType dest_type;
-  FileSystemFileUtil* src_file_system_file_util;
-  FileSystemFileUtil* dest_file_system_file_util;
+  FileSystemFileUtil* src_file_util;
+  FileSystemFileUtil* dest_file_util;
 
   if (!VerifyFileSystemPathForRead(src_path, &src_origin_url, &src_type,
-        &src_virtual_path_, &src_file_system_file_util) ||
+        &src_virtual_path_, &src_file_util) ||
       !VerifyFileSystemPathForWrite(dest_path, true /* create */,
-          &dest_origin_url, &dest_type, &dest_virtual_path_,
-          &dest_file_system_file_util)) {
+          &dest_origin_url, &dest_type, &dest_virtual_path_, &dest_file_util)) {
     delete this;
     return;
   }
@@ -232,12 +226,10 @@ void FileSystemOperation::Copy(const GURL& src_path,
   file_system_operation_context_.set_dest_origin_url(dest_origin_url);
   file_system_operation_context_.set_src_type(src_type);
   file_system_operation_context_.set_dest_type(dest_type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        src_file_system_file_util);
-  if (!file_system_operation_context_.dest_file_system_file_util())
-    file_system_operation_context_.set_dest_file_system_file_util(
-        dest_file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(src_file_util);
+  if (!file_system_operation_context_.dest_file_util())
+    file_system_operation_context_.set_dest_file_util(dest_file_util);
 
   GetUsageAndQuotaThenCallback(dest_origin_url, callback_factory_.NewCallback(
       &FileSystemOperation::DelayedCopyForQuota));
@@ -278,14 +270,13 @@ void FileSystemOperation::Move(const GURL& src_path,
   GURL dest_origin_url;
   FileSystemType src_type;
   FileSystemType dest_type;
-  FileSystemFileUtil* src_file_system_file_util;
-  FileSystemFileUtil* dest_file_system_file_util;
+  FileSystemFileUtil* src_file_util;
+  FileSystemFileUtil* dest_file_util;
 
   if (!VerifyFileSystemPathForWrite(src_path, false, &src_origin_url, &src_type,
-        &src_virtual_path_, &src_file_system_file_util) ||
+          &src_virtual_path_, &src_file_util) ||
       !VerifyFileSystemPathForWrite(dest_path, true /* create */,
-          &dest_origin_url, &dest_type, &dest_virtual_path_,
-          &dest_file_system_file_util)) {
+          &dest_origin_url, &dest_type, &dest_virtual_path_, &dest_file_util)) {
     delete this;
     return;
   }
@@ -293,12 +284,10 @@ void FileSystemOperation::Move(const GURL& src_path,
   file_system_operation_context_.set_dest_origin_url(dest_origin_url);
   file_system_operation_context_.set_src_type(src_type);
   file_system_operation_context_.set_dest_type(dest_type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        src_file_system_file_util);
-  if (!file_system_operation_context_.dest_file_system_file_util())
-    file_system_operation_context_.set_dest_file_system_file_util(
-        dest_file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(src_file_util);
+  if (!file_system_operation_context_.dest_file_util())
+    file_system_operation_context_.set_dest_file_util(dest_file_util);
 
   GetUsageAndQuotaThenCallback(dest_origin_url, callback_factory_.NewCallback(
       &FileSystemOperation::DelayedMoveForQuota));
@@ -338,17 +327,16 @@ void FileSystemOperation::DirectoryExists(const GURL& path) {
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path,
-      &file_system_file_util)) {
+      &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   FileSystemFileUtilProxy::GetFileInfo(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
@@ -364,17 +352,16 @@ void FileSystemOperation::FileExists(const GURL& path) {
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path,
-      &file_system_file_util)) {
+      &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   FileSystemFileUtilProxy::GetFileInfo(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
@@ -390,17 +377,16 @@ void FileSystemOperation::GetMetadata(const GURL& path) {
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path,
-      &file_system_file_util)) {
+      &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   FileSystemFileUtilProxy::GetFileInfo(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
@@ -416,17 +402,16 @@ void FileSystemOperation::ReadDirectory(const GURL& path) {
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForRead(path, &origin_url, &type, &virtual_path,
-      &file_system_file_util)) {
+      &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   FileSystemFileUtilProxy::ReadDirectory(
       file_system_operation_context_,
       proxy_, virtual_path, callback_factory_.NewCallback(
@@ -442,17 +427,16 @@ void FileSystemOperation::Remove(const GURL& path, bool recursive) {
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForWrite(path, false /* create */, &origin_url,
-      &type, &virtual_path, &file_system_file_util)) {
+      &type, &virtual_path, &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   FileSystemFileUtilProxy::Delete(
       file_system_operation_context_,
       proxy_, virtual_path, recursive, callback_factory_.NewCallback(
@@ -470,17 +454,16 @@ void FileSystemOperation::Write(
 #endif
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
-      &type, &src_virtual_path_, &file_system_file_util)) {
+      &type, &src_virtual_path_, &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   DCHECK(blob_url.is_valid());
   file_writer_delegate_.reset(new FileWriterDelegate(this, offset, proxy_));
   blob_request_.reset(
@@ -524,17 +507,16 @@ void FileSystemOperation::Truncate(const GURL& path, int64 length) {
 #endif
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForWrite(path, false /* create */, &origin_url,
-      &type, &src_virtual_path_, &file_system_file_util)) {
+      &type, &src_virtual_path_, &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   length_ = length;
 
   GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
@@ -576,17 +558,16 @@ void FileSystemOperation::TouchFile(const GURL& path,
   FilePath virtual_path;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
-      &type, &virtual_path, &file_system_file_util)) {
+      &type, &virtual_path, &file_util)) {
     delete this;
     return;
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   FileSystemFileUtilProxy::Touch(
       file_system_operation_context_,
       proxy_, virtual_path, last_access_time, last_modified_time,
@@ -604,7 +585,7 @@ void FileSystemOperation::OpenFile(const GURL& path,
   peer_handle_ = peer_handle;
   GURL origin_url;
   FileSystemType type;
-  FileSystemFileUtil* file_system_file_util;
+  FileSystemFileUtil* file_util;
   if (file_flags & (
       (base::PLATFORM_FILE_ENUMERATE | base::PLATFORM_FILE_TEMPORARY |
        base::PLATFORM_FILE_HIDDEN))) {
@@ -618,22 +599,21 @@ void FileSystemOperation::OpenFile(const GURL& path,
        base::PLATFORM_FILE_DELETE_ON_CLOSE |
        base::PLATFORM_FILE_WRITE_ATTRIBUTES)) {
     if (!VerifyFileSystemPathForWrite(path, true /* create */, &origin_url,
-        &type, &src_virtual_path_, &file_system_file_util)) {
+        &type, &src_virtual_path_, &file_util)) {
       delete this;
       return;
     }
   } else {
     if (!VerifyFileSystemPathForRead(path, &origin_url, &type,
-        &src_virtual_path_, &file_system_file_util)) {
+        &src_virtual_path_, &file_util)) {
       delete this;
       return;
     }
   }
   file_system_operation_context_.set_src_origin_url(origin_url);
   file_system_operation_context_.set_src_type(type);
-  if (!file_system_operation_context_.src_file_system_file_util())
-    file_system_operation_context_.set_src_file_system_file_util(
-        file_system_file_util);
+  if (!file_system_operation_context_.src_file_util())
+    file_system_operation_context_.set_src_file_util(file_util);
   file_flags_ = file_flags;
 
   GetUsageAndQuotaThenCallback(origin_url, callback_factory_.NewCallback(
@@ -868,7 +848,7 @@ void FileSystemOperation::OnFileOpenedForWrite(
 
 bool FileSystemOperation::VerifyFileSystemPathForRead(
     const GURL& path, GURL* origin_url, FileSystemType* type,
-    FilePath* virtual_path, FileSystemFileUtil** file_system_file_util) {
+    FilePath* virtual_path, FileSystemFileUtil** file_util) {
 
   // If we have no context, we just allow any operations, for testing.
   // TODO(ericu): Revisit this hack for security.
@@ -887,7 +867,7 @@ bool FileSystemOperation::VerifyFileSystemPathForRead(
 #endif
     *type = file_system_operation_context_.src_type();
     *origin_url = file_system_operation_context_.src_origin_url();
-    *file_system_file_util = NULL;
+    *file_util = NULL;
     return true;
   }
 
@@ -902,10 +882,9 @@ bool FileSystemOperation::VerifyFileSystemPathForRead(
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
-  DCHECK(file_system_file_util);
-  *file_system_file_util =
-      file_system_context()->path_manager()->GetFileSystemFileUtil(*type);
-  DCHECK(*file_system_file_util);
+  DCHECK(file_util);
+  *file_util = file_system_context()->path_manager()->GetFileUtil(*type);
+  DCHECK(*file_util);
 
   // We notify this read access whether the read access succeeds or not.
   // This must be ok since this is used to let the QM's eviction logic know
@@ -924,7 +903,7 @@ bool FileSystemOperation::VerifyFileSystemPathForRead(
 
 bool FileSystemOperation::VerifyFileSystemPathForWrite(
     const GURL& path, bool create, GURL* origin_url, FileSystemType* type,
-    FilePath* virtual_path, FileSystemFileUtil** file_system_file_util) {
+    FilePath* virtual_path, FileSystemFileUtil** file_util) {
 
   // If we have no context, we just allow any operations, for testing.
   // TODO(ericu): Revisit this hack for security.
@@ -943,7 +922,7 @@ bool FileSystemOperation::VerifyFileSystemPathForWrite(
 #endif
     *type = file_system_operation_context_.dest_type();
     *origin_url = file_system_operation_context_.dest_origin_url();
-    *file_system_file_util = NULL;
+    *file_util = NULL;
     return true;
   }
 
@@ -967,10 +946,9 @@ bool FileSystemOperation::VerifyFileSystemPathForWrite(
     dispatcher_->DidFail(base::PLATFORM_FILE_ERROR_SECURITY);
     return false;
   }
-  DCHECK(file_system_file_util);
-  *file_system_file_util =
-      file_system_context()->path_manager()->GetFileSystemFileUtil(*type);
-  DCHECK(*file_system_file_util);
+  DCHECK(file_util);
+  *file_util = file_system_context()->path_manager()->GetFileUtil(*type);
+  DCHECK(*file_util);
 
   return true;
 }
diff --git a/webkit/fileapi/file_system_operation.h b/webkit/fileapi/file_system_operation.h
index a03868e..cc1e34a 100644
--- a/webkit/fileapi/file_system_operation.h
+++ b/webkit/fileapi/file_system_operation.h
@@ -49,12 +49,12 @@ class FileSystemQuotaUtil;
 class FileSystemOperation {
  public:
   // |dispatcher| will be owned by this class.
-  // |file_system_file_util| is optional; if supplied, it will not be deleted by
+  // |file_util| is optional; if supplied, it will not be deleted by
   // the class.  It's expecting a pointer to a singleton.
   FileSystemOperation(FileSystemCallbackDispatcher* dispatcher,
                       scoped_refptr<base::MessageLoopProxy> proxy,
                       FileSystemContext* file_system_context,
-                      FileSystemFileUtil* file_system_file_util);
+                      FileSystemFileUtil* file_util);
   virtual ~FileSystemOperation();
 
   void OpenFileSystem(const GURL& origin_url,
@@ -184,7 +184,7 @@ class FileSystemOperation {
                                    GURL* root_url,
                                    FileSystemType* type,
                                    FilePath* virtual_path,
-                                   FileSystemFileUtil** file_system_file_util);
+                                   FileSystemFileUtil** file_util);
 
   // Checks the validity of a given |path| for writing, cracks the path into
   // root URL and virtual path components, and returns the correct
@@ -206,7 +206,7 @@ class FileSystemOperation {
                                     GURL* root_url,
                                     FileSystemType* type,
                                     FilePath* virtual_path,
-                                    FileSystemFileUtil** file_system_file_util);
+                                    FileSystemFileUtil** file_util);
 
 #ifndef NDEBUG
   enum OperationType {
diff --git a/webkit/fileapi/file_system_operation_context.cc b/webkit/fileapi/file_system_operation_context.cc
index b8a7c6f..5f0abf0 100644
--- a/webkit/fileapi/file_system_operation_context.cc
+++ b/webkit/fileapi/file_system_operation_context.cc
@@ -11,10 +11,10 @@ namespace fileapi {
 
 FileSystemOperationContext::FileSystemOperationContext(
     FileSystemContext* context,
-    FileSystemFileUtil* file_system_file_util)
+    FileSystemFileUtil* file_util)
     : file_system_context_(context),
-      src_file_system_file_util_(file_system_file_util),
-      dest_file_system_file_util_(file_system_file_util),
+      src_file_util_(file_util),
+      dest_file_util_(file_util),
       src_type_(kFileSystemTypeUnknown),
       dest_type_(kFileSystemTypeUnknown),
       allowed_bytes_growth_(0) {
@@ -26,7 +26,7 @@ FileSystemOperationContext::~FileSystemOperationContext() {
 FileSystemOperationContext*
 FileSystemOperationContext::CreateInheritedContextForDest() const {
   FileSystemOperationContext* context = new FileSystemOperationContext(
-      file_system_context_.get(), dest_file_system_file_util_);
+      file_system_context_.get(), dest_file_util_);
   context->set_src_origin_url(dest_origin_url_);
   context->set_src_type(dest_type_);
   context->set_allowed_bytes_growth(allowed_bytes_growth_);
diff --git a/webkit/fileapi/file_system_operation_context.h b/webkit/fileapi/file_system_operation_context.h
index 9ea088f..e61aac8 100644
--- a/webkit/fileapi/file_system_operation_context.h
+++ b/webkit/fileapi/file_system_operation_context.h
@@ -17,34 +17,33 @@ class FileSystemContext;
 
 class FileSystemOperationContext {
  public:
-  // The |file_system_file_util| parameter is so that unit tests can force their
-  // own preferred class in for both src and dest FSFU; in general these will
-  // get set later by the FileSystemOperation.
-  FileSystemOperationContext(
-      FileSystemContext* context,
-      FileSystemFileUtil* file_system_file_util);
+  // The |file_util| parameter is so that unit tests can force their own
+  // preferred class in for both src and dest FSFU; in general these will get
+  // set later by the FileSystemOperation.
+  FileSystemOperationContext(FileSystemContext* context,
+                             FileSystemFileUtil* file_util);
   ~FileSystemOperationContext();
 
   FileSystemContext* file_system_context() const {
     return file_system_context_.get();
   }
 
-  void set_src_file_system_file_util(FileSystemFileUtil* util) {
-    DCHECK(!src_file_system_file_util_);
-    src_file_system_file_util_ = util;
+  void set_src_file_util(FileSystemFileUtil* util) {
+    DCHECK(!src_file_util_);
+    src_file_util_ = util;
   }
 
-  FileSystemFileUtil* src_file_system_file_util() const {
-    return src_file_system_file_util_;
+  FileSystemFileUtil* src_file_util() const {
+    return src_file_util_;
   }
 
-  void set_dest_file_system_file_util(FileSystemFileUtil* util) {
-    DCHECK(!dest_file_system_file_util_);
-    dest_file_system_file_util_ = util;
+  void set_dest_file_util(FileSystemFileUtil* util) {
+    DCHECK(!dest_file_util_);
+    dest_file_util_ = util;
   }
 
-  FileSystemFileUtil* dest_file_system_file_util() const {
-    return dest_file_system_file_util_;
+  FileSystemFileUtil* dest_file_util() const {
+    return dest_file_util_;
   }
 
   void set_src_origin_url(const GURL& url) {
@@ -89,11 +88,10 @@ class FileSystemOperationContext {
 
  private:
   scoped_refptr<FileSystemContext> file_system_context_;
-  // These *_file_system_file_util_ are not "owned" by
-  // FileSystemOperationContext.  They are supposed to be pointers to objects
-  // that will outlive us.
-  FileSystemFileUtil* src_file_system_file_util_;
-  FileSystemFileUtil* dest_file_system_file_util_;
+  // These *_file_util_ are not "owned" by FileSystemOperationContext.  They
+  // are supposed to be pointers to objects that will outlive us.
+  FileSystemFileUtil* src_file_util_;
+  FileSystemFileUtil* dest_file_util_;
 
   GURL src_origin_url_;  // Also used for any single-path operation.
   GURL dest_origin_url_;
diff --git a/webkit/fileapi/file_system_operation_unittest.cc b/webkit/fileapi/file_system_operation_unittest.cc
index 50e5ea8..90f0031 100644
--- a/webkit/fileapi/file_system_operation_unittest.cc
+++ b/webkit/fileapi/file_system_operation_unittest.cc
@@ -19,7 +19,7 @@
 #include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_manager.h"
 
@@ -155,8 +155,7 @@ class FileSystemOperationTest : public testing::Test {
  public:
   FileSystemOperationTest()
       : status_(kFileOperationStatusNotSet),
-        local_file_util_(
-            new LocalFileSystemFileUtil(QuotaFileUtil::CreateDefault())) {
+        local_file_util_(new LocalFileUtil(QuotaFileUtil::CreateDefault())) {
     EXPECT_TRUE(base_.CreateUniqueTempDir());
   }
 
@@ -250,7 +249,7 @@ class FileSystemOperationTest : public testing::Test {
   std::vector<base::FileUtilProxy::Entry> entries_;
 
  private:
-  scoped_ptr<LocalFileSystemFileUtil> local_file_util_;
+  scoped_ptr<LocalFileUtil> local_file_util_;
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
   DISALLOW_COPY_AND_ASSIGN(FileSystemOperationTest);
diff --git a/webkit/fileapi/file_system_operation_write_unittest.cc b/webkit/fileapi/file_system_operation_write_unittest.cc
index df1ebba..f434042 100644
--- a/webkit/fileapi/file_system_operation_write_unittest.cc
+++ b/webkit/fileapi/file_system_operation_write_unittest.cc
@@ -28,7 +28,7 @@
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_manager.h"
 
@@ -67,8 +67,7 @@ class MockQuotaManager : public QuotaManager {
 class FileSystemOperationWriteTest : public testing::Test {
  public:
   FileSystemOperationWriteTest()
-      : local_file_util_(
-            new LocalFileSystemFileUtil(QuotaFileUtil::CreateDefault())),
+      : local_file_util_(new LocalFileUtil(QuotaFileUtil::CreateDefault())),
         loop_(MessageLoop::TYPE_IO),
         status_(base::PLATFORM_FILE_OK),
         bytes_written_(0),
@@ -100,7 +99,7 @@ class FileSystemOperationWriteTest : public testing::Test {
     return test_helper_.GetURLForPath(path);
   }
 
-  scoped_ptr<LocalFileSystemFileUtil> local_file_util_;
+  scoped_ptr<LocalFileUtil> local_file_util_;
   scoped_refptr<MockQuotaManager> quota_manager_;
   FileSystemTestOriginHelper test_helper_;
 
diff --git a/webkit/fileapi/file_system_path_manager.cc b/webkit/fileapi/file_system_path_manager.cc
index 043d6499..569c261 100644
--- a/webkit/fileapi/file_system_path_manager.cc
+++ b/webkit/fileapi/file_system_path_manager.cc
@@ -160,15 +160,15 @@ bool FileSystemPathManager::IsAccessAllowed(
   return true;
 }
 
-FileSystemFileUtil* FileSystemPathManager::GetFileSystemFileUtil(
+FileSystemFileUtil* FileSystemPathManager::GetFileUtil(
     FileSystemType type) const {
   switch (type) {
     case kFileSystemTypeTemporary:
     case kFileSystemTypePersistent:
-      return sandbox_provider_->GetFileSystemFileUtil();
+      return sandbox_provider_->GetFileUtil();
     case kFileSystemTypeExternal:
       if (external_provider_.get()) {
-        return external_provider_->GetFileSystemFileUtil();
+        return external_provider_->GetFileUtil();
       } else {
         NOTREACHED();
         return NULL;
diff --git a/webkit/fileapi/file_system_path_manager.h b/webkit/fileapi/file_system_path_manager.h
index 5ac3561..5c9600c 100644
--- a/webkit/fileapi/file_system_path_manager.h
+++ b/webkit/fileapi/file_system_path_manager.h
@@ -78,7 +78,7 @@ class FileSystemPathManager {
   bool IsAccessAllowed(const GURL& origin, FileSystemType type,
                        const FilePath& virtual_path);
 
-  FileSystemFileUtil* GetFileSystemFileUtil(FileSystemType type) const;
+  FileSystemFileUtil* GetFileUtil(FileSystemType type) const;
 
   SandboxMountPointProvider* sandbox_provider() const {
     return sandbox_provider_.get();
diff --git a/webkit/fileapi/file_system_quota_client_unittest.cc b/webkit/fileapi/file_system_quota_client_unittest.cc
index 026c377..6d32938 100644
--- a/webkit/fileapi/file_system_quota_client_unittest.cc
+++ b/webkit/fileapi/file_system_quota_client_unittest.cc
@@ -17,7 +17,7 @@
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/obfuscated_file_system_file_util.h"
+#include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_types.h"
@@ -147,9 +147,8 @@ class FileSystemQuotaClientTest : public testing::Test {
   bool CreateFileSystemDirectory(const FilePath& path,
                                  const std::string& origin_url,
                                  quota::StorageType type) {
-    FileSystemFileUtil* file_util =
-        file_system_context_->path_manager()->GetFileSystemFileUtil(
-            QuotaStorageTypeToFileSystemType(type));
+    FileSystemFileUtil* file_util = file_system_context_->path_manager()->
+        GetFileUtil(QuotaStorageTypeToFileSystemType(type));
 
     scoped_ptr<FileSystemOperationContext> context(
         CreateFileSystemOperationContext(file_util, path, origin_url, type));
@@ -169,7 +168,7 @@ class FileSystemQuotaClientTest : public testing::Test {
       return false;
 
     FileSystemFileUtil* file_util = file_system_context_->path_manager()->
-        sandbox_provider()->GetFileSystemFileUtil();
+        sandbox_provider()->GetFileUtil();
 
     scoped_ptr<FileSystemOperationContext> context(
         CreateFileSystemOperationContext(file_util, path, origin_url, type));
@@ -223,8 +222,7 @@ class FileSystemQuotaClientTest : public testing::Test {
           GURL(files[i].origin_url) == GURL(origin_url)) {
         FilePath path = FilePath().AppendASCII(files[i].name);
         if (!path.empty()) {
-          file_paths_cost +=
-              ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path);
+          file_paths_cost += ObfuscatedFileUtil::ComputeFilePathCost(path);
         }
       }
     }
diff --git a/webkit/fileapi/file_system_quota_unittest.cc b/webkit/fileapi/file_system_quota_unittest.cc
index 0879791..6eddf09 100644
--- a/webkit/fileapi/file_system_quota_unittest.cc
+++ b/webkit/fileapi/file_system_quota_unittest.cc
@@ -20,7 +20,7 @@
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/quota/quota_manager.h"
 
@@ -31,8 +31,7 @@ const int kFileOperationStatusNotSet = 1;
 class FileSystemQuotaTest : public testing::Test {
  public:
   FileSystemQuotaTest()
-      : local_file_util_(
-            new LocalFileSystemFileUtil(QuotaFileUtil::CreateDefault())),
+      : local_file_util_(new LocalFileUtil(QuotaFileUtil::CreateDefault())),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         status_(kFileOperationStatusNotSet),
         quota_status_(quota::kQuotaStatusUnknown),
@@ -121,7 +120,7 @@ class FileSystemQuotaTest : public testing::Test {
 
   ScopedTempDir work_dir_;
   scoped_refptr<quota::QuotaManager> quota_manager_;
-  scoped_ptr<LocalFileSystemFileUtil> local_file_util_;
+  scoped_ptr<LocalFileUtil> local_file_util_;
 
   base::ScopedCallbackFactory<FileSystemQuotaTest> callback_factory_;
 
diff --git a/webkit/fileapi/file_system_test_helper.cc b/webkit/fileapi/file_system_test_helper.cc
index b064e41..55e56c3 100644
--- a/webkit/fileapi/file_system_test_helper.cc
+++ b/webkit/fileapi/file_system_test_helper.cc
@@ -38,8 +38,7 @@ void FileSystemTestOriginHelper::SetUp(
 }
 
 void FileSystemTestOriginHelper::SetUp(
-    FileSystemContext* file_system_context,
-    FileSystemFileUtil* file_util) {
+    FileSystemContext* file_system_context, FileSystemFileUtil* file_util) {
   DCHECK(file_system_context->path_manager());
   DCHECK(file_system_context->path_manager()->sandbox_provider());
 
@@ -47,7 +46,7 @@ void FileSystemTestOriginHelper::SetUp(
   file_system_context_ = file_system_context;
   if (!file_util_)
     file_util_ = file_system_context->path_manager()->sandbox_provider()->
-        GetFileSystemFileUtil();
+        GetFileUtil();
   DCHECK(file_util_);
 
   // Prepare the origin's root directory.
diff --git a/webkit/fileapi/file_system_test_helper.h b/webkit/fileapi/file_system_test_helper.h
index 248290e..6562318 100644
--- a/webkit/fileapi/file_system_test_helper.h
+++ b/webkit/fileapi/file_system_test_helper.h
@@ -43,9 +43,9 @@ class FileSystemTestOriginHelper {
   // If you want to use more than one FileSystemTestOriginHelper in a single
   // base directory, they have to share a context, so that they don't have
   // multiple databases fighting over the lock to the origin directory [deep
-  // down inside ObfuscatedFileSystemFileUtil].
+  // down inside ObfuscatedFileUtil].
   void SetUp(FileSystemContext* file_system_context,
-      FileSystemFileUtil* file_util);
+             FileSystemFileUtil* file_util);
   void SetUp(const FilePath& base_dir,
              bool incognito_mode,
              bool unlimited_quota,
diff --git a/webkit/fileapi/file_system_url_request_job_unittest.cc b/webkit/fileapi/file_system_url_request_job_unittest.cc
index 52f1df8..3d09bd6 100644
--- a/webkit/fileapi/file_system_url_request_job_unittest.cc
+++ b/webkit/fileapi/file_system_url_request_job_unittest.cc
@@ -144,7 +144,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
   void CreateDirectory(const base::StringPiece& dir_name) {
     FilePath path = FilePath().AppendASCII(dir_name);
     FileSystemFileUtil* file_util = file_system_context_->path_manager()->
-        sandbox_provider()->GetFileSystemFileUtil();
+        sandbox_provider()->GetFileUtil();
     FileSystemOperationContext context(file_system_context_, file_util);
     context.set_src_origin_url(GURL("http://remote"));
     context.set_src_type(fileapi::kFileSystemTypeTemporary);
@@ -161,7 +161,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
                  const char* buf, int buf_size) {
     FilePath path = FilePath().AppendASCII(file_name);
     FileSystemFileUtil* file_util = file_system_context_->path_manager()->
-        sandbox_provider()->GetFileSystemFileUtil();
+        sandbox_provider()->GetFileUtil();
     FileSystemOperationContext context(file_system_context_, file_util);
     context.set_src_origin_url(GURL("http://remote"));
     context.set_src_type(fileapi::kFileSystemTypeTemporary);
diff --git a/webkit/fileapi/local_file_system_file_util.cc b/webkit/fileapi/local_file_util.cc
index 0ed3b94..223beea 100644
--- a/webkit/fileapi/local_file_system_file_util.cc
+++ b/webkit/fileapi/local_file_util.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
 
 #include "base/file_util_proxy.h"
 #include "googleurl/src/gurl.h"
@@ -14,15 +14,57 @@
 
 namespace fileapi {
 
-LocalFileSystemFileUtil::LocalFileSystemFileUtil(
-    FileSystemFileUtil* underlying_file_util)
-    : underlying_file_util_(underlying_file_util) {
+class LocalFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
+ public:
+  LocalFileEnumerator(const FilePath& platform_root_path,
+                                const FilePath& virtual_root_path,
+                                bool recursive,
+                                file_util::FileEnumerator::FileType file_type)
+      : file_enum_(platform_root_path, recursive, file_type),
+        platform_root_path_(platform_root_path),
+        virtual_root_path_(virtual_root_path) {
+  }
+
+  ~LocalFileEnumerator() {}
+
+  virtual FilePath Next() OVERRIDE;
+  virtual int64 Size() OVERRIDE;
+  virtual bool IsDirectory() OVERRIDE;
+
+ private:
+  file_util::FileEnumerator file_enum_;
+  file_util::FileEnumerator::FindInfo file_util_info_;
+  FilePath platform_root_path_;
+  FilePath virtual_root_path_;
+};
+
+FilePath LocalFileEnumerator::Next() {
+  FilePath next = file_enum_.Next();
+  if (next.empty())
+    return next;
+  file_enum_.GetFindInfo(&file_util_info_);
+
+  FilePath path;
+  platform_root_path_.AppendRelativePath(next, &path);
+  return virtual_root_path_.Append(path);
 }
 
-LocalFileSystemFileUtil::~LocalFileSystemFileUtil() {
+int64 LocalFileEnumerator::Size() {
+  return file_util::FileEnumerator::GetFilesize(file_util_info_);
 }
 
-PlatformFileError LocalFileSystemFileUtil::CreateOrOpen(
+bool LocalFileEnumerator::IsDirectory() {
+  return file_util::FileEnumerator::IsDirectory(file_util_info_);
+}
+
+LocalFileUtil::LocalFileUtil(FileSystemFileUtil* underlying_file_util)
+    : FileSystemFileUtil(underlying_file_util) {
+}
+
+LocalFileUtil::~LocalFileUtil() {
+}
+
+PlatformFileError LocalFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FilePath& file_path, int file_flags,
     PlatformFile* file_handle, bool* created) {
@@ -31,11 +73,11 @@ PlatformFileError LocalFileSystemFileUtil::CreateOrOpen(
           file_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->CreateOrOpen(
+  return underlying_file_util()->CreateOrOpen(
       context, local_path, file_flags, file_handle, created);
 }
 
-PlatformFileError LocalFileSystemFileUtil::EnsureFileExists(
+PlatformFileError LocalFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     bool* created) {
@@ -44,25 +86,25 @@ PlatformFileError LocalFileSystemFileUtil::EnsureFileExists(
           file_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->EnsureFileExists(
+  return underlying_file_util()->EnsureFileExists(
       context, local_path, created);
 }
 
-PlatformFileError LocalFileSystemFileUtil::GetLocalFilePath(
+PlatformFileError LocalFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
-    const FilePath& virtual_path,
-    FilePath* local_path) {
-  FilePath path =
+    const FilePath& file_path,
+    bool exclusive,
+    bool recursive) {
+  FilePath local_path =
       GetLocalPath(context, context->src_origin_url(), context->src_type(),
-                   virtual_path);
-  if (path.empty())
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-
-  *local_path = path;
-  return base::PLATFORM_FILE_OK;
+          file_path);
+  if (local_path.empty())
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  return underlying_file_util()->CreateDirectory(
+      context, local_path, exclusive, recursive);
 }
 
-PlatformFileError LocalFileSystemFileUtil::GetFileInfo(
+PlatformFileError LocalFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     base::PlatformFileInfo* file_info,
@@ -72,11 +114,11 @@ PlatformFileError LocalFileSystemFileUtil::GetFileInfo(
           file_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->GetFileInfo(
+  return underlying_file_util()->GetFileInfo(
       context, local_path, file_info, platform_file_path);
 }
 
-PlatformFileError LocalFileSystemFileUtil::ReadDirectory(
+PlatformFileError LocalFileUtil::ReadDirectory(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     std::vector<base::FileUtilProxy::Entry>* entries) {
@@ -86,85 +128,40 @@ PlatformFileError LocalFileSystemFileUtil::ReadDirectory(
           file_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->ReadDirectory(
+  return underlying_file_util()->ReadDirectory(
       context, local_path, entries);
 }
 
-PlatformFileError LocalFileSystemFileUtil::CreateDirectory(
+FileSystemFileUtil::AbstractFileEnumerator* LocalFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
-    const FilePath& file_path,
-    bool exclusive,
-    bool recursive) {
+    const FilePath& root_path) {
   FilePath local_path =
       GetLocalPath(context, context->src_origin_url(), context->src_type(),
-          file_path);
+          root_path);
   if (local_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->CreateDirectory(
-      context, local_path, exclusive, recursive);
-}
-
-PlatformFileError LocalFileSystemFileUtil::CopyOrMoveFile(
-    FileSystemOperationContext* context,
-    const FilePath& src_file_path,
-    const FilePath& dest_file_path,
-    bool copy) {
-  // TODO(ericu): If they share a root URL, this could be optimized.
-  FilePath local_src_path =
-      GetLocalPath(context, context->src_origin_url(), context->src_type(),
-          src_file_path);
-  if (local_src_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  FilePath local_dest_path =
-      GetLocalPath(context, context->dest_origin_url(), context->dest_type(),
-          dest_file_path);
-  if (local_dest_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->CopyOrMoveFile(
-      context, local_src_path, local_dest_path, copy);
-}
-
-// TODO(dmikurube): Make it independent from CopyOrMoveFile.
-PlatformFileError LocalFileSystemFileUtil::CopyInForeignFile(
-    FileSystemOperationContext* context,
-    const FilePath& src_file_path,
-    const FilePath& dest_file_path) {
-  if (src_file_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  FilePath local_dest_path =
-      GetLocalPath(context, context->dest_origin_url(), context->dest_type(),
-          dest_file_path);
-  if (local_dest_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->CopyOrMoveFile(
-      context, src_file_path, local_dest_path, true);
+    return new EmptyFileEnumerator();
+  return new LocalFileEnumerator(
+      local_path, root_path, true,
+      static_cast<file_util::FileEnumerator::FileType>(
+          file_util::FileEnumerator::FILES |
+          file_util::FileEnumerator::DIRECTORIES));
 }
 
-PlatformFileError LocalFileSystemFileUtil::DeleteFile(
+PlatformFileError LocalFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
-    const FilePath& file_path) {
-  FilePath local_path =
+    const FilePath& virtual_path,
+    FilePath* local_path) {
+  FilePath path =
       GetLocalPath(context, context->src_origin_url(), context->src_type(),
-          file_path);
-  if (local_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->DeleteFile(
-      context, local_path);
-}
+                   virtual_path);
+  if (path.empty())
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
-PlatformFileError LocalFileSystemFileUtil::DeleteSingleDirectory(
-    FileSystemOperationContext* context,
-    const FilePath& file_path) {
-  FilePath local_path =
-      GetLocalPath(context, context->src_origin_url(), context->src_type(),
-          file_path);
-  if (local_path.empty())
-    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->DeleteSingleDirectory(
-      context, local_path);
+  *local_path = path;
+  return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError LocalFileSystemFileUtil::Touch(
+PlatformFileError LocalFileUtil::Touch(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     const base::Time& last_access_time,
@@ -174,11 +171,11 @@ PlatformFileError LocalFileSystemFileUtil::Touch(
           file_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->Touch(
+  return underlying_file_util()->Touch(
       context, local_path, last_access_time, last_modified_time);
 }
 
-PlatformFileError LocalFileSystemFileUtil::Truncate(
+PlatformFileError LocalFileUtil::Truncate(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     int64 length) {
@@ -187,11 +184,11 @@ PlatformFileError LocalFileSystemFileUtil::Truncate(
           file_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
-  return underlying_file_util_->Truncate(
+  return underlying_file_util()->Truncate(
       context, local_path, length);
 }
 
-bool LocalFileSystemFileUtil::PathExists(
+bool LocalFileUtil::PathExists(
     FileSystemOperationContext* context,
     const FilePath& file_path) {
   FilePath local_path =
@@ -199,11 +196,11 @@ bool LocalFileSystemFileUtil::PathExists(
           file_path);
   if (local_path.empty())
     return false;
-  return underlying_file_util_->PathExists(
+  return underlying_file_util()->PathExists(
       context, local_path);
 }
 
-bool LocalFileSystemFileUtil::DirectoryExists(
+bool LocalFileUtil::DirectoryExists(
     FileSystemOperationContext* context,
     const FilePath& file_path) {
   FilePath local_path =
@@ -211,11 +208,11 @@ bool LocalFileSystemFileUtil::DirectoryExists(
           file_path);
   if (local_path.empty())
     return false;
-  return underlying_file_util_->DirectoryExists(
+  return underlying_file_util()->DirectoryExists(
       context, local_path);
 }
 
-bool LocalFileSystemFileUtil::IsDirectoryEmpty(
+bool LocalFileUtil::IsDirectoryEmpty(
     FileSystemOperationContext* context,
     const FilePath& file_path) {
   FilePath local_path =
@@ -223,71 +220,71 @@ bool LocalFileSystemFileUtil::IsDirectoryEmpty(
           file_path);
   if (local_path.empty())
     return true;
-  return underlying_file_util_->IsDirectoryEmpty(
+  return underlying_file_util()->IsDirectoryEmpty(
       context, local_path);
 }
 
-class LocalFileSystemFileEnumerator
-    : public FileSystemFileUtil::AbstractFileEnumerator {
- public:
-  LocalFileSystemFileEnumerator(const FilePath& platform_root_path,
-                                const FilePath& virtual_root_path,
-                                bool recursive,
-                                file_util::FileEnumerator::FileType file_type)
-      : file_enum_(platform_root_path, recursive, file_type),
-        platform_root_path_(platform_root_path),
-        virtual_root_path_(virtual_root_path) {
-  }
-
-  ~LocalFileSystemFileEnumerator() {}
-
-  virtual FilePath Next() OVERRIDE;
-  virtual int64 Size() OVERRIDE;
-  virtual bool IsDirectory() OVERRIDE;
-
- private:
-  file_util::FileEnumerator file_enum_;
-  file_util::FileEnumerator::FindInfo file_util_info_;
-  FilePath platform_root_path_;
-  FilePath virtual_root_path_;
-};
-
-FilePath LocalFileSystemFileEnumerator::Next() {
-  FilePath next = file_enum_.Next();
-  if (next.empty())
-    return next;
-  file_enum_.GetFindInfo(&file_util_info_);
-
-  FilePath path;
-  platform_root_path_.AppendRelativePath(next, &path);
-  return virtual_root_path_.Append(path);
+PlatformFileError LocalFileUtil::CopyOrMoveFile(
+    FileSystemOperationContext* context,
+    const FilePath& src_file_path,
+    const FilePath& dest_file_path,
+    bool copy) {
+  // TODO(ericu): If they share a root URL, this could be optimized.
+  FilePath local_src_path =
+      GetLocalPath(context, context->src_origin_url(), context->src_type(),
+          src_file_path);
+  if (local_src_path.empty())
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  FilePath local_dest_path =
+      GetLocalPath(context, context->dest_origin_url(), context->dest_type(),
+          dest_file_path);
+  if (local_dest_path.empty())
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  return underlying_file_util()->CopyOrMoveFile(
+      context, local_src_path, local_dest_path, copy);
 }
 
-int64 LocalFileSystemFileEnumerator::Size() {
-  return file_util::FileEnumerator::GetFilesize(file_util_info_);
+// TODO(dmikurube): Make it independent from CopyOrMoveFile.
+PlatformFileError LocalFileUtil::CopyInForeignFile(
+    FileSystemOperationContext* context,
+    const FilePath& src_file_path,
+    const FilePath& dest_file_path) {
+  if (src_file_path.empty())
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  FilePath local_dest_path =
+      GetLocalPath(context, context->dest_origin_url(), context->dest_type(),
+          dest_file_path);
+  if (local_dest_path.empty())
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  return underlying_file_util()->CopyOrMoveFile(
+      context, src_file_path, local_dest_path, true);
 }
 
-bool LocalFileSystemFileEnumerator::IsDirectory() {
-  return file_util::FileEnumerator::IsDirectory(file_util_info_);
+PlatformFileError LocalFileUtil::DeleteFile(
+    FileSystemOperationContext* context,
+    const FilePath& file_path) {
+  FilePath local_path =
+      GetLocalPath(context, context->src_origin_url(), context->src_type(),
+          file_path);
+  if (local_path.empty())
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  return underlying_file_util()->DeleteFile(
+      context, local_path);
 }
 
-FileSystemFileUtil::AbstractFileEnumerator*
-LocalFileSystemFileUtil::CreateFileEnumerator(
+PlatformFileError LocalFileUtil::DeleteSingleDirectory(
     FileSystemOperationContext* context,
-    const FilePath& root_path) {
+    const FilePath& file_path) {
   FilePath local_path =
       GetLocalPath(context, context->src_origin_url(), context->src_type(),
-          root_path);
+          file_path);
   if (local_path.empty())
-    return new EmptyFileEnumerator();
-  return new LocalFileSystemFileEnumerator(
-      local_path, root_path, true,
-      static_cast<file_util::FileEnumerator::FileType>(
-          file_util::FileEnumerator::FILES |
-          file_util::FileEnumerator::DIRECTORIES));
+    return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
+  return underlying_file_util()->DeleteSingleDirectory(
+      context, local_path);
 }
 
-FilePath LocalFileSystemFileUtil::GetLocalPath(
+FilePath LocalFileUtil::GetLocalPath(
     FileSystemOperationContext* context,
     const GURL& origin_url,
     FileSystemType type,
diff --git a/webkit/fileapi/local_file_system_file_util.h b/webkit/fileapi/local_file_util.h
index 314895e..cd564a4 100644
--- a/webkit/fileapi/local_file_system_file_util.h
+++ b/webkit/fileapi/local_file_util.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_FILE_UTIL_H_
-#define WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_FILE_UTIL_H_
+#ifndef WEBKIT_FILEAPI_LOCAL_FILE_UTIL_H_
+#define WEBKIT_FILEAPI_LOCAL_FILE_UTIL_H_
 
 #include <vector>
 
@@ -33,93 +33,77 @@ using base::PlatformFileError;
 class FileSystemOperationContext;
 
 // An instance of this class is created and owned by *MountPointProvider.
-class LocalFileSystemFileUtil : public FileSystemFileUtil {
+class LocalFileUtil : public FileSystemFileUtil {
  public:
   // |underlying_file_util| is owned by the instance.  It will be deleted by
   // the owner instance.  For example, it can be instanciated as follows:
-  // FileSystemFileUtil* file_system_file_util =
-  //     new LocalFileSystemFileUtil(new FileSystemFileUtil());
-  explicit LocalFileSystemFileUtil(FileSystemFileUtil* underlying_file_util);
-  virtual ~LocalFileSystemFileUtil();
+  // FileSystemFileUtil* file_util = new LocalFileUtil(new NativeFileUtil());
+  explicit LocalFileUtil(FileSystemFileUtil* underlying_file_util);
+  virtual ~LocalFileUtil();
 
   virtual PlatformFileError CreateOrOpen(
       FileSystemOperationContext* context,
       const FilePath& file_path,
       int file_flags,
       PlatformFile* file_handle,
-      bool* created);
-
+      bool* created) OVERRIDE;
   virtual PlatformFileError EnsureFileExists(
       FileSystemOperationContext* context,
-      const FilePath& file_path, bool* created);
-
-  virtual PlatformFileError GetLocalFilePath(
+      const FilePath& file_path, bool* created) OVERRIDE;
+  virtual PlatformFileError CreateDirectory(
       FileSystemOperationContext* context,
-      const FilePath& virtual_file,
-      FilePath* local_path);
-
+      const FilePath& file_path,
+      bool exclusive,
+      bool recursive) OVERRIDE;
   virtual PlatformFileError GetFileInfo(
       FileSystemOperationContext* context,
       const FilePath& file,
       base::PlatformFileInfo* file_info,
-      FilePath* platform_file);
-
+      FilePath* platform_file) OVERRIDE;
   virtual PlatformFileError ReadDirectory(
       FileSystemOperationContext* context,
       const FilePath& file_path,
-      std::vector<base::FileUtilProxy::Entry>* entries);
-
-  virtual PlatformFileError CreateDirectory(
-      FileSystemOperationContext* context,
-      const FilePath& file_path,
-      bool exclusive,
-      bool recursive);
-
-  virtual PlatformFileError CopyOrMoveFile(
-      FileSystemOperationContext* context,
-      const FilePath& src_file_path,
-      const FilePath& dest_file_path,
-      bool copy);
-
-  virtual PlatformFileError CopyInForeignFile(
-        FileSystemOperationContext* context,
-        const FilePath& src_file_path,
-        const FilePath& dest_file_path);
-
-  virtual PlatformFileError DeleteFile(
+      std::vector<base::FileUtilProxy::Entry>* entries) OVERRIDE;
+  virtual AbstractFileEnumerator* CreateFileEnumerator(
       FileSystemOperationContext* context,
-      const FilePath& file_path);
-
-  virtual PlatformFileError DeleteSingleDirectory(
+      const FilePath& root_path) OVERRIDE;
+  virtual PlatformFileError GetLocalFilePath(
       FileSystemOperationContext* context,
-      const FilePath& file_path);
-
+      const FilePath& virtual_file,
+      FilePath* local_path) OVERRIDE;
   virtual PlatformFileError Touch(
       FileSystemOperationContext* context,
       const FilePath& file_path,
       const base::Time& last_access_time,
-      const base::Time& last_modified_time);
-
+      const base::Time& last_modified_time) OVERRIDE;
   virtual PlatformFileError Truncate(
       FileSystemOperationContext* context,
       const FilePath& path,
-      int64 length);
-
+      int64 length) OVERRIDE;
   virtual bool PathExists(
       FileSystemOperationContext* context,
-      const FilePath& file_path);
-
+      const FilePath& file_path) OVERRIDE;
   virtual bool DirectoryExists(
       FileSystemOperationContext* context,
-      const FilePath& file_path);
-
+      const FilePath& file_path) OVERRIDE;
   virtual bool IsDirectoryEmpty(
       FileSystemOperationContext* context,
-      const FilePath& file_path);
-
-  virtual AbstractFileEnumerator* CreateFileEnumerator(
+      const FilePath& file_path) OVERRIDE;
+  virtual PlatformFileError CopyOrMoveFile(
+      FileSystemOperationContext* context,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path,
+      bool copy) OVERRIDE;
+  virtual PlatformFileError CopyInForeignFile(
+        FileSystemOperationContext* context,
+        const FilePath& src_file_path,
+        const FilePath& dest_file_path) OVERRIDE;
+  virtual PlatformFileError DeleteFile(
       FileSystemOperationContext* context,
-      const FilePath& root_path);
+      const FilePath& file_path) OVERRIDE;
+  virtual PlatformFileError DeleteSingleDirectory(
+      FileSystemOperationContext* context,
+      const FilePath& file_path) OVERRIDE;
 
  private:
   // Given the filesystem's root URL and a virtual path, produces a real, full
@@ -130,11 +114,9 @@ class LocalFileSystemFileUtil : public FileSystemFileUtil {
       FileSystemType type,
       const FilePath& virtual_path);
 
-  scoped_ptr<FileSystemFileUtil> underlying_file_util_;
-
-  DISALLOW_COPY_AND_ASSIGN(LocalFileSystemFileUtil);
+  DISALLOW_COPY_AND_ASSIGN(LocalFileUtil);
 };
 
 }  // namespace fileapi
 
-#endif  // WEBKIT_FILEAPI_LOCAL_FILE_SYSTEM_FILE_UTIL_H_
+#endif  // WEBKIT_FILEAPI_LOCAL_FILE_UTIL_H_
diff --git a/webkit/fileapi/local_file_system_file_util_unittest.cc b/webkit/fileapi/local_file_util_unittest.cc
index 5f3906e..119d919 100644
--- a/webkit/fileapi/local_file_system_file_util_unittest.cc
+++ b/webkit/fileapi/local_file_util_unittest.cc
@@ -18,16 +18,16 @@
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_types.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
+#include "webkit/fileapi/local_file_util.h"
+#include "webkit/fileapi/native_file_util.h"
 
 namespace fileapi {
 
-// TODO(dmikurube): Cover all public methods in LocalFileSystemFileUtil.
-class LocalFileSystemFileUtilTest : public testing::Test {
+// TODO(dmikurube): Cover all public methods in LocalFileUtil.
+class LocalFileUtilTest : public testing::Test {
  public:
-  LocalFileSystemFileUtilTest()
-      : local_file_util_(
-            new LocalFileSystemFileUtil(new FileSystemFileUtil())),
+  LocalFileUtilTest()
+      : local_file_util_(new LocalFileUtil(new NativeFileUtil())),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   }
 
@@ -46,7 +46,7 @@ class LocalFileSystemFileUtilTest : public testing::Test {
     return context;
   }
 
-  LocalFileSystemFileUtil* FileUtil() {
+  LocalFileUtil* FileUtil() {
     return local_file_util_.get();
   }
 
@@ -94,16 +94,16 @@ class LocalFileSystemFileUtilTest : public testing::Test {
   }
 
  private:
-  scoped_ptr<LocalFileSystemFileUtil> local_file_util_;
+  scoped_ptr<LocalFileUtil> local_file_util_;
   ScopedTempDir data_dir_;
   FileSystemTestOriginHelper test_helper_;
 
-  base::ScopedCallbackFactory<LocalFileSystemFileUtilTest> callback_factory_;
+  base::ScopedCallbackFactory<LocalFileUtilTest> callback_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(LocalFileSystemFileUtilTest);
+  DISALLOW_COPY_AND_ASSIGN(LocalFileUtilTest);
 };
 
-TEST_F(LocalFileSystemFileUtilTest, CreateAndClose) {
+TEST_F(LocalFileUtilTest, CreateAndClose) {
   const char *file_name = "test_file";
   base::PlatformFile file_handle;
   bool created;
@@ -119,7 +119,7 @@ TEST_F(LocalFileSystemFileUtilTest, CreateAndClose) {
       FileUtil()->Close(context.get(), file_handle));
 }
 
-TEST_F(LocalFileSystemFileUtilTest, EnsureFileExists) {
+TEST_F(LocalFileUtilTest, EnsureFileExists) {
   const char *file_name = "foobar";
   bool created;
   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(file_name, &created));
@@ -132,7 +132,7 @@ TEST_F(LocalFileSystemFileUtilTest, EnsureFileExists) {
   EXPECT_FALSE(created);
 }
 
-TEST_F(LocalFileSystemFileUtilTest, Truncate) {
+TEST_F(LocalFileUtilTest, Truncate) {
   const char *file_name = "truncated";
   bool created;
   ASSERT_EQ(base::PLATFORM_FILE_OK, EnsureFileExists(file_name, &created));
@@ -148,7 +148,7 @@ TEST_F(LocalFileSystemFileUtilTest, Truncate) {
   EXPECT_EQ(1020, GetSize(file_name));
 }
 
-TEST_F(LocalFileSystemFileUtilTest, CopyFile) {
+TEST_F(LocalFileUtilTest, CopyFile) {
   const char *from_file = "fromfile";
   const char *to_file1 = "tofile1";
   const char *to_file2 = "tofile2";
@@ -180,7 +180,7 @@ TEST_F(LocalFileSystemFileUtilTest, CopyFile) {
   EXPECT_EQ(1020, GetSize(to_file2));
 }
 
-TEST_F(LocalFileSystemFileUtilTest, CopyDirectory) {
+TEST_F(LocalFileUtilTest, CopyDirectory) {
   const char *from_dir = "fromdir";
   const char *from_file = "fromdir/fromfile";
   const char *to_dir = "todir";
@@ -215,7 +215,7 @@ TEST_F(LocalFileSystemFileUtilTest, CopyDirectory) {
   EXPECT_EQ(1020, GetSize(to_file));
 }
 
-TEST_F(LocalFileSystemFileUtilTest, MoveFile) {
+TEST_F(LocalFileUtilTest, MoveFile) {
   const char *from_file = "fromfile";
   const char *to_file = "tofile";
   bool created;
@@ -239,7 +239,7 @@ TEST_F(LocalFileSystemFileUtilTest, MoveFile) {
   EXPECT_EQ(1020, GetSize(to_file));
 }
 
-TEST_F(LocalFileSystemFileUtilTest, MoveDirectory) {
+TEST_F(LocalFileUtilTest, MoveDirectory) {
   const char *from_dir = "fromdir";
   const char *from_file = "fromdir/fromfile";
   const char *to_dir = "todir";
diff --git a/webkit/fileapi/native_file_util.cc b/webkit/fileapi/native_file_util.cc
new file mode 100644
index 0000000..c7ee8fc
--- /dev/null
+++ b/webkit/fileapi/native_file_util.cc
@@ -0,0 +1,291 @@
+// 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 "webkit/fileapi/native_file_util.h"
+
+#include <vector>
+
+#include "base/file_util.h"
+#include "base/memory/scoped_ptr.h"
+#include "webkit/fileapi/file_system_operation_context.h"
+
+namespace fileapi {
+
+class NativeFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
+ public:
+  NativeFileEnumerator(const FilePath& root_path,
+                       bool recursive,
+                       file_util::FileEnumerator::FileType file_type)
+    : file_enum_(root_path, recursive, file_type) {
+  }
+
+  ~NativeFileEnumerator() {}
+
+  virtual FilePath Next() OVERRIDE;
+  virtual int64 Size() OVERRIDE;
+  virtual bool IsDirectory() OVERRIDE;
+
+ private:
+  file_util::FileEnumerator file_enum_;
+  file_util::FileEnumerator::FindInfo file_util_info_;
+};
+
+FilePath NativeFileEnumerator::Next() {
+  FilePath rv = file_enum_.Next();
+  if (!rv.empty())
+    file_enum_.GetFindInfo(&file_util_info_);
+  return rv;
+}
+
+int64 NativeFileEnumerator::Size() {
+  return file_util::FileEnumerator::GetFilesize(file_util_info_);
+}
+
+bool NativeFileEnumerator::IsDirectory() {
+  return file_util::FileEnumerator::IsDirectory(file_util_info_);
+}
+
+PlatformFileError NativeFileUtil::CreateOrOpen(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path, int file_flags,
+    PlatformFile* file_handle, bool* created) {
+  if (!file_util::DirectoryExists(file_path.DirName())) {
+    // If its parent does not exist, should return NOT_FOUND error.
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  }
+  PlatformFileError error_code = base::PLATFORM_FILE_OK;
+  *file_handle = base::CreatePlatformFile(file_path, file_flags,
+                                          created, &error_code);
+  return error_code;
+}
+
+PlatformFileError NativeFileUtil::Close(
+    FileSystemOperationContext* unused,
+    PlatformFile file_handle) {
+  if (!base::ClosePlatformFile(file_handle))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError NativeFileUtil::EnsureFileExists(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path,
+    bool* created) {
+  if (!file_util::DirectoryExists(file_path.DirName()))
+    // If its parent does not exist, should return NOT_FOUND error.
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  PlatformFileError error_code = base::PLATFORM_FILE_OK;
+  // Tries to create the |file_path| exclusively.  This should fail
+  // with base::PLATFORM_FILE_ERROR_EXISTS if the path already exists.
+  PlatformFile handle = base::CreatePlatformFile(
+      file_path,
+      base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_READ,
+      created, &error_code);
+  if (error_code == base::PLATFORM_FILE_ERROR_EXISTS) {
+    // Make sure created_ is false.
+    if (created)
+      *created = false;
+    error_code = base::PLATFORM_FILE_OK;
+  }
+  if (handle != base::kInvalidPlatformFileValue)
+    base::ClosePlatformFile(handle);
+  return error_code;
+}
+
+PlatformFileError NativeFileUtil::CreateDirectory(
+    FileSystemOperationContext* context,
+    const FilePath& file_path,
+    bool exclusive,
+    bool recursive) {
+  // If parent dir of file doesn't exist.
+  if (!recursive && !file_util::PathExists(file_path.DirName()))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+
+  bool path_exists = file_util::PathExists(file_path);
+  if (exclusive && path_exists)
+    return base::PLATFORM_FILE_ERROR_EXISTS;
+
+  // If file exists at the path.
+  if (path_exists && !file_util::DirectoryExists(file_path))
+    return base::PLATFORM_FILE_ERROR_EXISTS;
+
+  if (!file_util::CreateDirectory(file_path))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError NativeFileUtil::GetFileInfo(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path,
+    base::PlatformFileInfo* file_info,
+    FilePath* platform_file_path) {
+  if (!file_util::PathExists(file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  // TODO(rkc): Fix this hack once we have refactored file_util to handle
+  // symlinks correctly.
+  // http://code.google.com/p/chromium-os/issues/detail?id=15948
+  if (file_util::IsLink(file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  if (!file_util::GetFileInfo(file_path, file_info))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  *platform_file_path = file_path;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError NativeFileUtil::ReadDirectory(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path,
+    std::vector<base::FileUtilProxy::Entry>* entries) {
+  // TODO(kkanetkar): Implement directory read in multiple chunks.
+  if (!file_util::DirectoryExists(file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+
+  file_util::FileEnumerator file_enum(
+      file_path, false, static_cast<file_util::FileEnumerator::FileType>(
+      file_util::FileEnumerator::FILES |
+      file_util::FileEnumerator::DIRECTORIES));
+  FilePath current;
+  while (!(current = file_enum.Next()).empty()) {
+    base::FileUtilProxy::Entry entry;
+    file_util::FileEnumerator::FindInfo info;
+    file_enum.GetFindInfo(&info);
+    entry.is_directory = file_enum.IsDirectory(info);
+    // This will just give the entry's name instead of entire path
+    // if we use current.value().
+    entry.name = file_util::FileEnumerator::GetFilename(info).value();
+    entry.size = file_util::FileEnumerator::GetFilesize(info);
+    entry.last_modified_time =
+        file_util::FileEnumerator::GetLastModifiedTime(info);
+    // TODO(rkc): Fix this also once we've refactored file_util
+    // http://code.google.com/p/chromium-os/issues/detail?id=15948
+    // This currently just prevents a file from showing up at all
+    // if it's a link, hence preventing arbitary 'read' exploits.
+    if (!file_util::IsLink(file_path.Append(entry.name)))
+      entries->push_back(entry);
+  }
+  return base::PLATFORM_FILE_OK;
+}
+
+FileSystemFileUtil::AbstractFileEnumerator*
+NativeFileUtil::CreateFileEnumerator(
+    FileSystemOperationContext* unused,
+    const FilePath& root_path) {
+  return new NativeFileEnumerator(
+      root_path, true, static_cast<file_util::FileEnumerator::FileType>(
+      file_util::FileEnumerator::FILES |
+      file_util::FileEnumerator::DIRECTORIES));
+}
+
+PlatformFileError NativeFileUtil::GetLocalFilePath(
+    FileSystemOperationContext* unused,
+    const FilePath& virtual_path,
+    FilePath* local_path) {
+  *local_path = virtual_path;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError NativeFileUtil::Touch(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path,
+    const base::Time& last_access_time,
+    const base::Time& last_modified_time) {
+  if (!file_util::TouchFile(
+          file_path, last_access_time, last_modified_time))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError NativeFileUtil::Truncate(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path,
+    int64 length) {
+  PlatformFileError error_code(base::PLATFORM_FILE_ERROR_FAILED);
+  PlatformFile file =
+      base::CreatePlatformFile(
+          file_path,
+          base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_WRITE,
+          NULL,
+          &error_code);
+  if (error_code != base::PLATFORM_FILE_OK) {
+    return error_code;
+  }
+  DCHECK_NE(base::kInvalidPlatformFileValue, file);
+  if (!base::TruncatePlatformFile(file, length))
+    error_code = base::PLATFORM_FILE_ERROR_FAILED;
+  base::ClosePlatformFile(file);
+  return error_code;
+}
+
+bool NativeFileUtil::PathExists(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path) {
+  return file_util::PathExists(file_path);
+}
+
+bool NativeFileUtil::DirectoryExists(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path) {
+  return file_util::DirectoryExists(file_path);
+}
+
+bool NativeFileUtil::IsDirectoryEmpty(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path) {
+  return file_util::IsDirectoryEmpty(file_path);
+}
+
+PlatformFileError NativeFileUtil::CopyOrMoveFile(
+      FileSystemOperationContext* unused,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path,
+      bool copy) {
+  if (copy) {
+    if (file_util::CopyFile(src_file_path, dest_file_path))
+      return base::PLATFORM_FILE_OK;
+  } else {
+    DCHECK(!file_util::DirectoryExists(src_file_path));
+    if (file_util::Move(src_file_path, dest_file_path))
+      return base::PLATFORM_FILE_OK;
+  }
+  return base::PLATFORM_FILE_ERROR_FAILED;
+}
+
+PlatformFileError NativeFileUtil::CopyInForeignFile(
+      FileSystemOperationContext* context,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path) {
+  return CopyOrMoveFile(context, src_file_path, dest_file_path, true);
+}
+
+PlatformFileError NativeFileUtil::DeleteFile(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path) {
+  if (!file_util::PathExists(file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  if (file_util::DirectoryExists(file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
+  if (!file_util::Delete(file_path, false))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError NativeFileUtil::DeleteSingleDirectory(
+    FileSystemOperationContext* unused,
+    const FilePath& file_path) {
+  if (!file_util::PathExists(file_path))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  if (!file_util::DirectoryExists(file_path)) {
+    // TODO(dmikurube): Check if this error code is appropriate.
+    return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+  }
+  if (!file_util::IsDirectoryEmpty(file_path)) {
+    // TODO(dmikurube): Check if this error code is appropriate.
+    return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
+  }
+  if (!file_util::Delete(file_path, false))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  return base::PLATFORM_FILE_OK;
+}
+
+}  // namespace fileapi
diff --git a/webkit/fileapi/native_file_util.h b/webkit/fileapi/native_file_util.h
new file mode 100644
index 0000000..5669680
--- /dev/null
+++ b/webkit/fileapi/native_file_util.h
@@ -0,0 +1,103 @@
+// 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.
+
+#ifndef WEBKIT_FILEAPI_NATIVE_FILE_UTIL_H_
+#define WEBKIT_FILEAPI_NATIVE_FILE_UTIL_H_
+
+#include "base/file_path.h"
+#include "base/file_util_proxy.h"
+#include "base/platform_file.h"
+#include "webkit/fileapi/file_system_file_util.h"
+
+namespace base {
+class Time;
+}
+
+namespace fileapi {
+
+using base::PlatformFile;
+using base::PlatformFileError;
+class FileSystemOperationContext;
+
+// TODO(dmikurube): Add unit tests for NativeFileUtil.
+// This class handles accessing the OS native filesystem.
+class NativeFileUtil : public FileSystemFileUtil {
+ public:
+  NativeFileUtil() {}
+  virtual ~NativeFileUtil() {}
+
+  virtual PlatformFileError CreateOrOpen(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path,
+      int file_flags,
+      PlatformFile* file_handle,
+      bool* created) OVERRIDE;
+  virtual PlatformFileError Close(
+      FileSystemOperationContext* unused,
+      PlatformFile) OVERRIDE;
+  virtual PlatformFileError EnsureFileExists(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path, bool* created) OVERRIDE;
+  virtual PlatformFileError CreateDirectory(
+      FileSystemOperationContext* context,
+      const FilePath& file_path,
+      bool exclusive,
+      bool recursive) OVERRIDE;
+  virtual PlatformFileError GetFileInfo(
+      FileSystemOperationContext* unused,
+      const FilePath& file_,
+      base::PlatformFileInfo* file_info,
+      FilePath* platform_path) OVERRIDE;
+  virtual PlatformFileError ReadDirectory(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path,
+      std::vector<base::FileUtilProxy::Entry>* entries) OVERRIDE;
+  virtual AbstractFileEnumerator* CreateFileEnumerator(
+      FileSystemOperationContext* unused,
+      const FilePath& root_path) OVERRIDE;
+  virtual PlatformFileError GetLocalFilePath(
+      FileSystemOperationContext* unused,
+      const FilePath& virtual_path,
+      FilePath* local_path) OVERRIDE;
+  virtual PlatformFileError Touch(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path,
+      const base::Time& last_access_time,
+      const base::Time& last_modified_time) OVERRIDE;
+  virtual PlatformFileError Truncate(
+      FileSystemOperationContext* unused,
+      const FilePath& path,
+      int64 length) OVERRIDE;
+  virtual bool PathExists(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path) OVERRIDE;
+  virtual bool DirectoryExists(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path) OVERRIDE;
+  virtual bool IsDirectoryEmpty(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path) OVERRIDE;
+  virtual PlatformFileError CopyOrMoveFile(
+      FileSystemOperationContext* unused,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path,
+      bool copy) OVERRIDE;
+  virtual PlatformFileError CopyInForeignFile(
+        FileSystemOperationContext* unused,
+        const FilePath& src_file_path,
+        const FilePath& dest_file_path) OVERRIDE;
+  virtual PlatformFileError DeleteFile(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path) OVERRIDE;
+  virtual PlatformFileError DeleteSingleDirectory(
+      FileSystemOperationContext* unused,
+      const FilePath& file_path) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NativeFileUtil);
+};
+
+}  // namespace fileapi
+
+#endif  // WEBKIT_FILEAPI_NATIVE_FILE_UTIL_H_
diff --git a/webkit/fileapi/obfuscated_file_system_file_util.cc b/webkit/fileapi/obfuscated_file_util.cc
index 6c51cba..385393b 100644
--- a/webkit/fileapi/obfuscated_file_system_file_util.cc
+++ b/webkit/fileapi/obfuscated_file_util.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "webkit/fileapi/obfuscated_file_system_file_util.h"
+#include "webkit/fileapi/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
@@ -104,18 +104,165 @@ namespace fileapi {
 using base::PlatformFile;
 using base::PlatformFileError;
 
-ObfuscatedFileSystemFileUtil::ObfuscatedFileSystemFileUtil(
+class ObfuscatedFileEnumerator
+    : public FileSystemFileUtil::AbstractFileEnumerator {
+ public:
+  ObfuscatedFileEnumerator(
+      const FilePath& base_path,
+      FileSystemDirectoryDatabase* db,
+      FileSystemOperationContext* context,
+      FileSystemFileUtil* underlying_file_util,
+      const FilePath& virtual_root_path)
+      : base_path_(base_path),
+        db_(db),
+        context_(context),
+        underlying_file_util_(underlying_file_util) {
+    DCHECK(db_);
+    DCHECK(context_);
+    DCHECK(underlying_file_util_);
+
+    FileId file_id;
+    FileInfo file_info;
+    if (!db_->GetFileWithPath(virtual_root_path, &file_id))
+      return;
+    if (!db_->GetFileInfo(file_id, &file_info))
+      return;
+    if (!file_info.is_directory())
+      return;
+    FileRecord record = { file_id, file_info, virtual_root_path };
+    display_queue_.push(record);
+    Next();  // Enumerators don't include the directory itself.
+  }
+
+  ~ObfuscatedFileEnumerator() {}
+
+  virtual FilePath Next() OVERRIDE {
+    ProcessRecurseQueue();
+    if (display_queue_.empty())
+      return FilePath();
+    current_ = display_queue_.front();
+    display_queue_.pop();
+    if (current_.file_info.is_directory())
+      recurse_queue_.push(current_);
+    return current_.file_path;
+  }
+
+  virtual int64 Size() OVERRIDE {
+    if (IsDirectory())
+      return 0;
+
+    base::PlatformFileInfo file_info;
+    FilePath platform_file_path;
+
+    FilePath local_path = base_path_.Append(current_.file_info.data_path);
+    base::PlatformFileError error = underlying_file_util_->GetFileInfo(
+        context_, local_path, &file_info, &platform_file_path);
+    if (error != base::PLATFORM_FILE_OK) {
+      LOG(WARNING) << "Lost a backing file.";
+      return 0;
+    }
+    return file_info.size;
+  }
+
+  virtual bool IsDirectory() OVERRIDE {
+    return current_.file_info.is_directory();
+  }
+
+ private:
+  typedef FileSystemDirectoryDatabase::FileId FileId;
+  typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
+
+  struct FileRecord {
+    FileId file_id;
+    FileInfo file_info;
+    FilePath file_path;
+  };
+
+  void ProcessRecurseQueue() {
+    while (display_queue_.empty() && !recurse_queue_.empty()) {
+      FileRecord directory = recurse_queue_.front();
+      std::vector<FileId> children;
+      recurse_queue_.pop();
+      if (!db_->ListChildren(directory.file_id, &children))
+        return;
+      std::vector<FileId>::iterator iter;
+      for (iter = children.begin(); iter != children.end(); ++iter) {
+        FileRecord child;
+        child.file_id = *iter;
+        if (!db_->GetFileInfo(child.file_id, &child.file_info))
+          return;
+        child.file_path = directory.file_path.Append(child.file_info.name);
+        display_queue_.push(child);
+      }
+    }
+  }
+
+  std::queue<FileRecord> display_queue_;
+  std::queue<FileRecord> recurse_queue_;
+  FileRecord current_;
+  FilePath base_path_;
+  FileSystemDirectoryDatabase* db_;
+  FileSystemOperationContext* context_;
+  FileSystemFileUtil* underlying_file_util_;
+};
+
+class ObfuscatedOriginEnumerator
+    : public ObfuscatedFileUtil::AbstractOriginEnumerator {
+ public:
+  typedef FileSystemOriginDatabase::OriginRecord OriginRecord;
+  ObfuscatedOriginEnumerator(
+      FileSystemOriginDatabase* origin_database,
+      const FilePath& base_path)
+      : base_path_(base_path) {
+    if (origin_database)
+      origin_database->ListAllOrigins(&origins_);
+  }
+
+  ~ObfuscatedOriginEnumerator() {}
+
+  // Returns the next origin.  Returns empty if there are no more origins.
+  virtual GURL Next() OVERRIDE {
+    OriginRecord record;
+    if (!origins_.empty()) {
+      record = origins_.back();
+      origins_.pop_back();
+    }
+    current_ = record;
+    return GetOriginURLFromIdentifier(record.origin);
+  }
+
+  // Returns the current origin's information.
+  virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
+    if (current_.path.empty())
+      return false;
+    FilePath::StringType type_string =
+        ObfuscatedFileUtil::GetDirectoryNameForType(type);
+    if (type_string.empty()) {
+      NOTREACHED();
+      return false;
+    }
+    FilePath path = base_path_.Append(current_.path).Append(type_string);
+    return file_util::DirectoryExists(path);
+  }
+
+ private:
+  std::vector<OriginRecord> origins_;
+  OriginRecord current_;
+  FilePath base_path_;
+};
+
+ObfuscatedFileUtil::ObfuscatedFileUtil(
     const FilePath& file_system_directory,
     FileSystemFileUtil* underlying_file_util)
-    : file_system_directory_(file_system_directory),
-      underlying_file_util_(underlying_file_util) {
+    : FileSystemFileUtil(underlying_file_util),
+      file_system_directory_(file_system_directory) {
 }
 
-ObfuscatedFileSystemFileUtil::~ObfuscatedFileSystemFileUtil() {
+ObfuscatedFileUtil::~ObfuscatedFileUtil() {
   DropDatabases();
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::CreateOrOpen(
+PlatformFileError ObfuscatedFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FilePath& virtual_path, int file_flags,
     PlatformFile* file_handle, bool* created) {
@@ -158,7 +305,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateOrOpen(
     return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
   FilePath local_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
-  base::PlatformFileError error = underlying_file_util_->CreateOrOpen(
+  base::PlatformFileError error = underlying_file_util()->CreateOrOpen(
       context, local_path, file_flags, file_handle, created);
   if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
     // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker.
@@ -172,7 +319,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateOrOpen(
   return error;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::EnsureFileExists(
+PlatformFileError ObfuscatedFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     bool* created) {
@@ -208,21 +355,62 @@ PlatformFileError ObfuscatedFileSystemFileUtil::EnsureFileExists(
   return error;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::GetLocalFilePath(
+PlatformFileError ObfuscatedFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
-    FilePath* local_path) {
-  FilePath path =
-      GetLocalPath(context->src_origin_url(), context->src_type(),
-                   virtual_path);
-  if (path.empty())
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+    bool exclusive,
+    bool recursive) {
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
+  if (!db)
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  FileId file_id;
+  if (db->GetFileWithPath(virtual_path, &file_id)) {
+    FileInfo file_info;
+    if (exclusive)
+      return base::PLATFORM_FILE_ERROR_EXISTS;
+    if (!db->GetFileInfo(file_id, &file_info)) {
+      NOTREACHED();
+      return base::PLATFORM_FILE_ERROR_FAILED;
+    }
+    if (!file_info.is_directory())
+      return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
+    return base::PLATFORM_FILE_OK;
+  }
 
-  *local_path = path;
+  std::vector<FilePath::StringType> components;
+  virtual_path.GetComponents(&components);
+  FileId parent_id = 0;
+  size_t index;
+  for (index = 0; index < components.size(); ++index) {
+    FilePath::StringType name = components[index];
+    if (name == FILE_PATH_LITERAL("/"))
+      continue;
+    if (!db->GetChildWithName(parent_id, name, &parent_id))
+      break;
+  }
+  if (!recursive && components.size() - index > 1)
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  for (; index < components.size(); ++index) {
+    FileInfo file_info;
+    file_info.name = components[index];
+    if (file_info.name == FILE_PATH_LITERAL("/"))
+      continue;
+    file_info.modification_time = base::Time::Now();
+    file_info.parent_id = parent_id;
+    if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
+      return base::PLATFORM_FILE_ERROR_NO_SPACE;
+    if (!db->AddFileInfo(file_info, &parent_id)) {
+      NOTREACHED();
+      return base::PLATFORM_FILE_ERROR_FAILED;
+    }
+    UpdatePathQuotaUsage(context, context->src_origin_url(),
+      context->src_type(), 1, file_info.name.size());
+  }
   return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::GetFileInfo(
+PlatformFileError ObfuscatedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     base::PlatformFileInfo* file_info,
@@ -239,7 +427,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::GetFileInfo(
                              &local_info, file_info, platform_file_path);
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::ReadDirectory(
+PlatformFileError ObfuscatedFileUtil::ReadDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     std::vector<base::FileUtilProxy::Entry>* entries) {
@@ -295,62 +483,145 @@ PlatformFileError ObfuscatedFileSystemFileUtil::ReadDirectory(
   return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::CreateDirectory(
+FileSystemFileUtil::AbstractFileEnumerator*
+ObfuscatedFileUtil::CreateFileEnumerator(
+    FileSystemOperationContext* context,
+    const FilePath& root_path) {
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
+  if (!db)
+    return new FileSystemFileUtil::EmptyFileEnumerator();
+  return new ObfuscatedFileEnumerator(
+      GetDirectoryForOriginAndType(context->src_origin_url(),
+                                   context->src_type(), false),
+      db,
+      context,
+      underlying_file_util(),
+      root_path);
+}
+
+PlatformFileError ObfuscatedFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
-    bool exclusive,
-    bool recursive) {
+    FilePath* local_path) {
+  FilePath path =
+      GetLocalPath(context->src_origin_url(), context->src_type(),
+                   virtual_path);
+  if (path.empty())
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+
+  *local_path = path;
+  return base::PLATFORM_FILE_OK;
+}
+
+PlatformFileError ObfuscatedFileUtil::Touch(
+    FileSystemOperationContext* context,
+    const FilePath& virtual_path,
+    const base::Time& last_access_time,
+    const base::Time& last_modified_time) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      context->src_origin_url(), context->src_type(), true);
+      context->src_origin_url(), context->src_type(), false);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileId file_id;
-  if (db->GetFileWithPath(virtual_path, &file_id)) {
-    FileInfo file_info;
-    if (exclusive)
-      return base::PLATFORM_FILE_ERROR_EXISTS;
-    if (!db->GetFileInfo(file_id, &file_info)) {
-      NOTREACHED();
+  if (!db->GetFileWithPath(virtual_path, &file_id))
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+
+  FileInfo file_info;
+  if (!db->GetFileInfo(file_id, &file_info)) {
+    NOTREACHED();
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  }
+  if (file_info.is_directory()) {
+    file_info.modification_time = last_modified_time;
+    if (!db->UpdateFileInfo(file_id, file_info))
       return base::PLATFORM_FILE_ERROR_FAILED;
-    }
-    if (!file_info.is_directory())
-      return base::PLATFORM_FILE_ERROR_NOT_A_DIRECTORY;
     return base::PLATFORM_FILE_OK;
   }
+  FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
+    context->src_type(), file_info.data_path);
+  return underlying_file_util()->Touch(
+      context, data_path, last_access_time, last_modified_time);
+}
 
-  std::vector<FilePath::StringType> components;
-  virtual_path.GetComponents(&components);
-  FileId parent_id = 0;
-  size_t index;
-  for (index = 0; index < components.size(); ++index) {
-    FilePath::StringType name = components[index];
-    if (name == FILE_PATH_LITERAL("/"))
-      continue;
-    if (!db->GetChildWithName(parent_id, name, &parent_id))
-      break;
-  }
-  if (!recursive && components.size() - index > 1)
+PlatformFileError ObfuscatedFileUtil::Truncate(
+    FileSystemOperationContext* context,
+    const FilePath& virtual_path,
+    int64 length) {
+  FilePath local_path =
+      GetLocalPath(context->src_origin_url(), context->src_type(),
+          virtual_path);
+  if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  for (; index < components.size(); ++index) {
-    FileInfo file_info;
-    file_info.name = components[index];
-    if (file_info.name == FILE_PATH_LITERAL("/"))
-      continue;
-    file_info.modification_time = base::Time::Now();
-    file_info.parent_id = parent_id;
-    if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
-      return base::PLATFORM_FILE_ERROR_NO_SPACE;
-    if (!db->AddFileInfo(file_info, &parent_id)) {
-      NOTREACHED();
-      return base::PLATFORM_FILE_ERROR_FAILED;
-    }
-    UpdatePathQuotaUsage(context, context->src_origin_url(),
-      context->src_type(), 1, file_info.name.size());
+  return underlying_file_util()->Truncate(
+      context, local_path, length);
+}
+
+bool ObfuscatedFileUtil::PathExists(
+    FileSystemOperationContext* context,
+    const FilePath& virtual_path) {
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
+  if (!db)
+    return false;
+  FileId file_id;
+  return db->GetFileWithPath(virtual_path, &file_id);
+}
+
+bool ObfuscatedFileUtil::DirectoryExists(
+    FileSystemOperationContext* context,
+    const FilePath& virtual_path) {
+  if (IsRootDirectory(virtual_path)) {
+    // It's questionable whether we should return true or false for the
+    // root directory of nonexistent origin, but here we return true
+    // as the current implementation of ReadDirectory always returns an empty
+    // array (rather than erroring out with NOT_FOUND_ERR even) for
+    // nonexistent origins.
+    // Note: if you're going to change this behavior please also consider
+    // changiing the ReadDirectory's behavior!
+    return true;
   }
-  return base::PLATFORM_FILE_OK;
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
+  if (!db)
+    return false;
+  FileId file_id;
+  if (!db->GetFileWithPath(virtual_path, &file_id))
+    return false;
+  FileInfo file_info;
+  if (!db->GetFileInfo(file_id, &file_info)) {
+    NOTREACHED();
+    return false;
+  }
+  return file_info.is_directory();
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
+bool ObfuscatedFileUtil::IsDirectoryEmpty(
+    FileSystemOperationContext* context,
+    const FilePath& virtual_path) {
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
+  if (!db)
+    return true;  // Not a great answer, but it's what others do.
+  FileId file_id;
+  if (!db->GetFileWithPath(virtual_path, &file_id))
+    return true;  // Ditto.
+  FileInfo file_info;
+  if (!db->GetFileInfo(file_id, &file_info)) {
+    DCHECK(!file_id);
+    // It's the root directory and the database hasn't been initialized yet.
+    return true;
+  }
+  if (!file_info.is_directory())
+    return true;
+  std::vector<FileId> children;
+  // TODO(ericu): This could easily be made faster with help from the database.
+  if (!db->ListChildren(file_id, &children))
+    return true;
+  return children.empty();
+}
+
+PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path,
@@ -399,7 +670,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
   if (copy) {
     FilePath src_data_path = DataPathToLocalPath(context->src_origin_url(),
       context->src_type(), src_file_info.data_path);
-    if (!underlying_file_util_->PathExists(context, src_data_path)) {
+    if (!underlying_file_util()->PathExists(context, src_data_path)) {
       // TODO(tzik): Also invalidate on-memory usage cache in UsageTracker.
       context->file_system_context()->GetQuotaUtil(context->src_type())->
           InvalidateUsageCache(context->src_origin_url(),
@@ -411,7 +682,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
     if (overwrite) {
       FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(),
         context->src_type(), dest_file_info.data_path);
-      return underlying_file_util_->CopyOrMoveFile(context,
+      return underlying_file_util()->CopyOrMoveFile(context,
           src_data_path, dest_data_path, copy);
     } else {
       FileId dest_parent_id;
@@ -436,7 +707,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
       FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(),
         context->src_type(), dest_file_info.data_path);
       if (base::PLATFORM_FILE_OK !=
-          underlying_file_util_->DeleteFile(context, dest_data_path))
+          underlying_file_util()->DeleteFile(context, dest_data_path))
         LOG(WARNING) << "Leaked a backing file.";
       UpdatePathQuotaUsage(context, context->src_origin_url(),
           context->src_type(), -1,
@@ -468,7 +739,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::CopyInForeignFile(
+PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path) {
@@ -487,7 +758,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CopyInForeignFile(
     }
     FilePath dest_data_path = DataPathToLocalPath(context->dest_origin_url(),
       context->dest_type(), dest_file_info.data_path);
-    return underlying_file_util_->CopyOrMoveFile(context,
+    return underlying_file_util()->CopyOrMoveFile(context,
         src_file_path, dest_data_path, true /* copy */);
   } else {
     FileId dest_parent_id;
@@ -505,7 +776,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CopyInForeignFile(
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::DeleteFile(
+PlatformFileError ObfuscatedFileUtil::DeleteFile(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
@@ -530,12 +801,12 @@ PlatformFileError ObfuscatedFileSystemFileUtil::DeleteFile(
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   if (base::PLATFORM_FILE_OK !=
-      underlying_file_util_->DeleteFile(context, data_path))
+      underlying_file_util()->DeleteFile(context, data_path))
     LOG(WARNING) << "Leaked a backing file.";
   return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::DeleteSingleDirectory(
+PlatformFileError ObfuscatedFileUtil::DeleteSingleDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
@@ -558,287 +829,178 @@ PlatformFileError ObfuscatedFileSystemFileUtil::DeleteSingleDirectory(
   return base::PLATFORM_FILE_OK;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::Touch(
-    FileSystemOperationContext* context,
-    const FilePath& virtual_path,
-    const base::Time& last_access_time,
-    const base::Time& last_modified_time) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      context->src_origin_url(), context->src_type(), false);
-  if (!db)
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  FileId file_id;
-  if (!db->GetFileWithPath(virtual_path, &file_id))
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-
-  FileInfo file_info;
-  if (!db->GetFileInfo(file_id, &file_info)) {
-    NOTREACHED();
-    return base::PLATFORM_FILE_ERROR_FAILED;
-  }
-  if (file_info.is_directory()) {
-    file_info.modification_time = last_modified_time;
-    if (!db->UpdateFileInfo(file_id, file_info))
-      return base::PLATFORM_FILE_ERROR_FAILED;
-    return base::PLATFORM_FILE_OK;
+FilePath ObfuscatedFileUtil::GetDirectoryForOriginAndType(
+    const GURL& origin, FileSystemType type, bool create) {
+  FilePath origin_dir = GetDirectoryForOrigin(origin, create);
+  if (origin_dir.empty())
+    return FilePath();
+  FilePath::StringType type_string = GetDirectoryNameForType(type);
+  if (type_string.empty()) {
+    LOG(WARNING) << "Unknown filesystem type requested:" << type;
+    return FilePath();
   }
-  FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
-    context->src_type(), file_info.data_path);
-  return underlying_file_util_->Touch(
-      context, data_path, last_access_time, last_modified_time);
+  FilePath path = origin_dir.Append(type_string);
+  if (!file_util::DirectoryExists(path) &&
+      (!create || !file_util::CreateDirectory(path)))
+    return FilePath();
+  return path;
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::Truncate(
-    FileSystemOperationContext* context,
-    const FilePath& virtual_path,
-    int64 length) {
-  FilePath local_path =
-      GetLocalPath(context->src_origin_url(), context->src_type(),
-          virtual_path);
-  if (local_path.empty())
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  return underlying_file_util_->Truncate(
-      context, local_path, length);
-}
+bool ObfuscatedFileUtil::DeleteDirectoryForOriginAndType(
+    const GURL& origin, FileSystemType type) {
+  FilePath origin_type_path = GetDirectoryForOriginAndType(origin, type, false);
+  if (!file_util::PathExists(origin_type_path))
+    return true;
 
-bool ObfuscatedFileSystemFileUtil::PathExists(
-    FileSystemOperationContext* context,
-    const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      context->src_origin_url(), context->src_type(), false);
-  if (!db)
+  // TODO(dmikurube): Consider the return value of DestroyDirectoryDatabase.
+  // We ignore its error now since 1) it doesn't matter the final result, and
+  // 2) it always returns false in Windows because of LevelDB's implementation.
+  // Information about failure would be useful for debugging.
+  DestroyDirectoryDatabase(origin, type);
+  if (!file_util::Delete(origin_type_path, true /* recursive */))
     return false;
-  FileId file_id;
-  return db->GetFileWithPath(virtual_path, &file_id);
-}
 
-bool ObfuscatedFileSystemFileUtil::DirectoryExists(
-    FileSystemOperationContext* context,
-    const FilePath& virtual_path) {
-  if (IsRootDirectory(virtual_path)) {
-    // It's questionable whether we should return true or false for the
-    // root directory of nonexistent origin, but here we return true
-    // as the current implementation of ReadDirectory always returns an empty
-    // array (rather than erroring out with NOT_FOUND_ERR even) for
-    // nonexistent origins.
-    // Note: if you're going to change this behavior please also consider
-    // changiing the ReadDirectory's behavior!
-    return true;
-  }
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      context->src_origin_url(), context->src_type(), false);
-  if (!db)
-    return false;
-  FileId file_id;
-  if (!db->GetFileWithPath(virtual_path, &file_id))
-    return false;
-  FileInfo file_info;
-  if (!db->GetFileInfo(file_id, &file_info)) {
-    NOTREACHED();
-    return false;
+  FilePath origin_path = origin_type_path.DirName();
+  DCHECK_EQ(origin_path.value(), GetDirectoryForOrigin(origin, false).value());
+
+  // Delete the origin directory if the deleted one was the last remaining
+  // type for the origin.
+  if (file_util::Delete(origin_path, false /* recursive */)) {
+    InitOriginDatabase(false);
+    if (origin_database_.get())
+      origin_database_->RemovePathForOrigin(GetOriginIdentifierFromURL(origin));
   }
-  return file_info.is_directory();
+
+  // At this point we are sure we had successfully deleted the origin/type
+  // directory, so just returning true here.
+  return true;
 }
 
-bool ObfuscatedFileSystemFileUtil::IsDirectoryEmpty(
-    FileSystemOperationContext* context,
-    const FilePath& virtual_path) {
+bool ObfuscatedFileUtil::MigrateFromOldSandbox(
+    const GURL& origin_url, FileSystemType type, const FilePath& src_root) {
+  if (!DestroyDirectoryDatabase(origin_url, type))
+    return false;
+  FilePath dest_root = GetDirectoryForOriginAndType(origin_url, type, true);
+  if (dest_root.empty())
+    return false;
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      context->src_origin_url(), context->src_type(), false);
+      origin_url, type, true);
   if (!db)
-    return true;  // Not a great answer, but it's what others do.
-  FileId file_id;
-  if (!db->GetFileWithPath(virtual_path, &file_id))
-    return true;  // Ditto.
-  FileInfo file_info;
-  if (!db->GetFileInfo(file_id, &file_info)) {
-    DCHECK(!file_id);
-    // It's the root directory and the database hasn't been initialized yet.
-    return true;
-  }
-  if (!file_info.is_directory())
-    return true;
-  std::vector<FileId> children;
-  // TODO(ericu): This could easily be made faster with help from the database.
-  if (!db->ListChildren(file_id, &children))
-    return true;
-  return children.empty();
-}
-
-class ObfuscatedFileSystemFileEnumerator
-    : public FileSystemFileUtil::AbstractFileEnumerator {
- public:
-  ObfuscatedFileSystemFileEnumerator(
-      const FilePath& base_path,
-      FileSystemDirectoryDatabase* db,
-      FileSystemOperationContext* context,
-      FileSystemFileUtil* underlying_file_util,
-      const FilePath& virtual_root_path)
-      : base_path_(base_path),
-        db_(db),
-        context_(context),
-        underlying_file_util_(underlying_file_util) {
-    DCHECK(db_);
-    DCHECK(context_);
-    DCHECK(underlying_file_util_);
-
-    FileId file_id;
-    FileInfo file_info;
-    if (!db_->GetFileWithPath(virtual_root_path, &file_id))
-      return;
-    if (!db_->GetFileInfo(file_id, &file_info))
-      return;
-    if (!file_info.is_directory())
-      return;
-    FileRecord record = { file_id, file_info, virtual_root_path };
-    display_queue_.push(record);
-    Next();  // Enumerators don't include the directory itself.
-  }
-
-  ~ObfuscatedFileSystemFileEnumerator() {}
-
-  virtual FilePath Next() OVERRIDE {
-    ProcessRecurseQueue();
-    if (display_queue_.empty())
-      return FilePath();
-    current_ = display_queue_.front();
-    display_queue_.pop();
-    if (current_.file_info.is_directory())
-      recurse_queue_.push(current_);
-    return current_.file_path;
-  }
-
-  virtual int64 Size() OVERRIDE {
-    if (IsDirectory())
-      return 0;
-
-    base::PlatformFileInfo file_info;
-    FilePath platform_file_path;
+    return false;
 
-    FilePath local_path = base_path_.Append(current_.file_info.data_path);
-    base::PlatformFileError error = underlying_file_util_->GetFileInfo(
-        context_, local_path, &file_info, &platform_file_path);
-    if (error != base::PLATFORM_FILE_OK) {
-      LOG(WARNING) << "Lost a backing file.";
-      return 0;
+  file_util::FileEnumerator file_enum(src_root, true,
+      static_cast<file_util::FileEnumerator::FileType>(
+          file_util::FileEnumerator::FILES |
+          file_util::FileEnumerator::DIRECTORIES));
+  FilePath src_full_path;
+  size_t root_path_length = src_root.value().length() + 1;  // +1 for the slash
+  while (!(src_full_path = file_enum.Next()).empty()) {
+    file_util::FileEnumerator::FindInfo info;
+    file_enum.GetFindInfo(&info);
+    FilePath relative_virtual_path =
+        FilePath(src_full_path.value().substr(root_path_length));
+    if (relative_virtual_path.empty()) {
+      LOG(WARNING) << "Failed to convert path to relative: " <<
+          src_full_path.value();
+      return false;
     }
-    return file_info.size;
-  }
-
-  virtual bool IsDirectory() OVERRIDE {
-    return current_.file_info.is_directory();
-  }
-
- private:
-  typedef FileSystemDirectoryDatabase::FileId FileId;
-  typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
-
-  struct FileRecord {
     FileId file_id;
-    FileInfo file_info;
-    FilePath file_path;
-  };
-
-  void ProcessRecurseQueue() {
-    while (display_queue_.empty() && !recurse_queue_.empty()) {
-      FileRecord directory = recurse_queue_.front();
-      std::vector<FileId> children;
-      recurse_queue_.pop();
-      if (!db_->ListChildren(directory.file_id, &children))
-        return;
-      std::vector<FileId>::iterator iter;
-      for (iter = children.begin(); iter != children.end(); ++iter) {
-        FileRecord child;
-        child.file_id = *iter;
-        if (!db_->GetFileInfo(child.file_id, &child.file_info))
-          return;
-        child.file_path = directory.file_path.Append(child.file_info.name);
-        display_queue_.push(child);
-      }
+    if (db->GetFileWithPath(relative_virtual_path, &file_id)) {
+      NOTREACHED();  // File already exists.
+      return false;
     }
-  }
-
-  std::queue<FileRecord> display_queue_;
-  std::queue<FileRecord> recurse_queue_;
-  FileRecord current_;
-  FilePath base_path_;
-  FileSystemDirectoryDatabase* db_;
-  FileSystemOperationContext* context_;
-  FileSystemFileUtil* underlying_file_util_;
-};
-
-class ObfuscatedFileSystemOriginEnumerator
-    : public ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator {
- public:
-  typedef FileSystemOriginDatabase::OriginRecord OriginRecord;
-  ObfuscatedFileSystemOriginEnumerator(
-      FileSystemOriginDatabase* origin_database,
-      const FilePath& base_path)
-      : base_path_(base_path) {
-    if (origin_database)
-      origin_database->ListAllOrigins(&origins_);
-  }
-
-  ~ObfuscatedFileSystemOriginEnumerator() {}
-
-  // Returns the next origin.  Returns empty if there are no more origins.
-  virtual GURL Next() OVERRIDE {
-    OriginRecord record;
-    if (!origins_.empty()) {
-      record = origins_.back();
-      origins_.pop_back();
+    if (!db->GetFileWithPath(relative_virtual_path.DirName(), &file_id)) {
+      NOTREACHED();  // Parent doesn't exist.
+      return false;
     }
-    current_ = record;
-    return GetOriginURLFromIdentifier(record.origin);
-  }
 
-  // Returns the current origin's information.
-  virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
-    if (current_.path.empty())
-      return false;
-    FilePath::StringType type_string =
-        ObfuscatedFileSystemFileUtil::GetDirectoryNameForType(type);
-    if (type_string.empty()) {
+    FileInfo file_info;
+    file_info.name = src_full_path.BaseName().value();
+    if (file_util::FileEnumerator::IsDirectory(info)) {
+#if defined(OS_WIN)
+      file_info.modification_time =
+          base::Time::FromFileTime(info.ftLastWriteTime);
+#elif defined(OS_POSIX)
+      file_info.modification_time = base::Time::FromTimeT(info.stat.st_mtime);
+#endif
+    } else {
+      file_info.data_path =
+          FilePath(kLegacyDataDirectory).Append(relative_virtual_path);
+    }
+    file_info.parent_id = file_id;
+    if (!db->AddFileInfo(file_info, &file_id)) {
       NOTREACHED();
       return false;
     }
-    FilePath path = base_path_.Append(current_.path).Append(type_string);
-    return file_util::DirectoryExists(path);
   }
+  // TODO(ericu): Should we adjust the mtime of the root directory to match as
+  // well?
+  FilePath legacy_dest_dir = dest_root.Append(kLegacyDataDirectory);
 
- private:
-  std::vector<OriginRecord> origins_;
-  OriginRecord current_;
-  FilePath base_path_;
-};
+  if (!file_util::Move(src_root, legacy_dest_dir)) {
+    LOG(WARNING) <<
+        "The final step of a migration failed; I'll try to clean up.";
+    db = NULL;
+    DestroyDirectoryDatabase(origin_url, type);
+    return false;
+  }
+  return true;
+}
 
-ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator*
-ObfuscatedFileSystemFileUtil::CreateOriginEnumerator() {
+// static
+FilePath::StringType ObfuscatedFileUtil::GetDirectoryNameForType(
+    FileSystemType type) {
+  switch (type) {
+    case kFileSystemTypeTemporary:
+      return kTemporaryDirectoryName;
+    case kFileSystemTypePersistent:
+      return kPersistentDirectoryName;
+    case kFileSystemTypeUnknown:
+    default:
+      return FilePath::StringType();
+  }
+}
+
+ObfuscatedFileUtil::AbstractOriginEnumerator*
+ObfuscatedFileUtil::CreateOriginEnumerator() {
   std::vector<FileSystemOriginDatabase::OriginRecord> origins;
 
   InitOriginDatabase(false);
-  return new ObfuscatedFileSystemOriginEnumerator(
+  return new ObfuscatedOriginEnumerator(
       origin_database_.get(), file_system_directory_);
 }
 
-FileSystemFileUtil::AbstractFileEnumerator*
-ObfuscatedFileSystemFileUtil::CreateFileEnumerator(
-    FileSystemOperationContext* context,
-    const FilePath& root_path) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      context->src_origin_url(), context->src_type(), false);
-  if (!db)
-    return new FileSystemFileUtil::EmptyFileEnumerator();
-  return new ObfuscatedFileSystemFileEnumerator(
-      GetDirectoryForOriginAndType(context->src_origin_url(),
-                                   context->src_type(), false),
-      db,
-      context,
-      underlying_file_util_.get(),
-      root_path);
+bool ObfuscatedFileUtil::DestroyDirectoryDatabase(
+    const GURL& origin, FileSystemType type) {
+  std::string type_string =
+      FileSystemPathManager::GetFileSystemTypeString(type);
+  if (type_string.empty()) {
+    LOG(WARNING) << "Unknown filesystem type requested:" << type;
+    return true;
+  }
+  std::string key = GetOriginIdentifierFromURL(origin) + type_string;
+  DirectoryMap::iterator iter = directories_.find(key);
+  if (iter != directories_.end()) {
+    FileSystemDirectoryDatabase* database = iter->second;
+    directories_.erase(iter);
+    delete database;
+  }
+
+  FilePath path = GetDirectoryForOriginAndType(origin, type, false);
+  if (path.empty())
+    return true;
+  if (!file_util::DirectoryExists(path))
+    return true;
+  path = path.AppendASCII(kDirectoryDatabaseName);
+  return FileSystemDirectoryDatabase::DestroyDatabase(path);
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::GetFileInfoInternal(
+// static
+int64 ObfuscatedFileUtil::ComputeFilePathCost(const FilePath& path) {
+  return GetPathQuotaUsage(1, path.BaseName().value().size());
+}
+
+PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal(
     FileSystemDirectoryDatabase* db,
     FileSystemOperationContext* context,
     FileId file_id,
@@ -867,11 +1029,11 @@ PlatformFileError ObfuscatedFileSystemFileUtil::GetFileInfoInternal(
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), local_info->data_path);
-  return underlying_file_util_->GetFileInfo(
+  return underlying_file_util()->GetFileInfo(
       context, data_path, file_info, platform_file_path);
 }
 
-PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
+PlatformFileError ObfuscatedFileUtil::CreateFile(
     FileSystemOperationContext* context,
     const GURL& origin_url, FileSystemType type, const FilePath& source_path,
     FileInfo* file_info, int file_flags, PlatformFile* handle) {
@@ -894,7 +1056,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
   local_path = local_path.AppendASCII(StringPrintf("%02" PRIu64,
                                                    directory_number));
   PlatformFileError error;
-  error = underlying_file_util_->CreateDirectory(
+  error = underlying_file_util()->CreateDirectory(
       context, local_path, false /* exclusive */, false /* recursive */);
   if (base::PLATFORM_FILE_OK != error)
     return error;
@@ -906,12 +1068,12 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
   if (!source_path.empty()) {
     DCHECK(!file_flags);
     DCHECK(!handle);
-    error = underlying_file_util_->CopyOrMoveFile(
+    error = underlying_file_util()->CopyOrMoveFile(
       context, source_path, local_path, true /* copy */);
     created = true;
   } else {
     FilePath path;
-    underlying_file_util_->GetLocalFilePath(context, local_path, &path);
+    underlying_file_util()->GetLocalFilePath(context, local_path, &path);
     if (file_util::PathExists(path)) {
       if (!file_util::Delete(path, true)) {
         NOTREACHED();
@@ -923,12 +1085,12 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
     }
 
     if (handle) {
-      error = underlying_file_util_->CreateOrOpen(
+      error = underlying_file_util()->CreateOrOpen(
         context, local_path, file_flags, handle, &created);
       // If this succeeds, we must close handle on any subsequent error.
     } else {
       DCHECK(!file_flags);  // file_flags is only used by CreateOrOpen.
-      error = underlying_file_util_->EnsureFileExists(
+      error = underlying_file_util()->EnsureFileExists(
           context, local_path, &created);
     }
   }
@@ -940,7 +1102,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
-      underlying_file_util_->DeleteFile(context, local_path);
+      underlying_file_util()->DeleteFile(context, local_path);
     }
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
@@ -951,7 +1113,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
     }
-    underlying_file_util_->DeleteFile(context, local_path);
+    underlying_file_util()->DeleteFile(context, local_path);
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   UpdatePathQuotaUsage(context, origin_url, type, 1, file_info->name.size());
@@ -959,7 +1121,7 @@ PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
   return base::PLATFORM_FILE_OK;
 }
 
-FilePath ObfuscatedFileSystemFileUtil::GetLocalPath(
+FilePath ObfuscatedFileUtil::GetLocalPath(
     const GURL& origin_url,
     FileSystemType type,
     const FilePath& virtual_path) {
@@ -978,139 +1140,7 @@ FilePath ObfuscatedFileSystemFileUtil::GetLocalPath(
   return DataPathToLocalPath(origin_url, type, file_info.data_path);
 }
 
-FilePath ObfuscatedFileSystemFileUtil::GetDirectoryForOriginAndType(
-    const GURL& origin, FileSystemType type, bool create) {
-  FilePath origin_dir = GetDirectoryForOrigin(origin, create);
-  if (origin_dir.empty())
-    return FilePath();
-  FilePath::StringType type_string = GetDirectoryNameForType(type);
-  if (type_string.empty()) {
-    LOG(WARNING) << "Unknown filesystem type requested:" << type;
-    return FilePath();
-  }
-  FilePath path = origin_dir.Append(type_string);
-  if (!file_util::DirectoryExists(path) &&
-      (!create || !file_util::CreateDirectory(path)))
-    return FilePath();
-  return path;
-}
-
-bool ObfuscatedFileSystemFileUtil::DeleteDirectoryForOriginAndType(
-    const GURL& origin, FileSystemType type) {
-  FilePath origin_type_path = GetDirectoryForOriginAndType(origin, type, false);
-  if (!file_util::PathExists(origin_type_path))
-    return true;
-
-  // TODO(dmikurube): Consider the return value of DestroyDirectoryDatabase.
-  // We ignore its error now since 1) it doesn't matter the final result, and
-  // 2) it always returns false in Windows because of LevelDB's implementation.
-  // Information about failure would be useful for debugging.
-  DestroyDirectoryDatabase(origin, type);
-  if (!file_util::Delete(origin_type_path, true /* recursive */))
-    return false;
-
-  FilePath origin_path = origin_type_path.DirName();
-  DCHECK_EQ(origin_path.value(), GetDirectoryForOrigin(origin, false).value());
-
-  // Delete the origin directory if the deleted one was the last remaining
-  // type for the origin.
-  if (file_util::Delete(origin_path, false /* recursive */)) {
-    InitOriginDatabase(false);
-    if (origin_database_.get())
-      origin_database_->RemovePathForOrigin(GetOriginIdentifierFromURL(origin));
-  }
-
-  // At this point we are sure we had successfully deleted the origin/type
-  // directory, so just returning true here.
-  return true;
-}
-
-bool ObfuscatedFileSystemFileUtil::MigrateFromOldSandbox(
-    const GURL& origin_url, FileSystemType type, const FilePath& src_root) {
-  if (!DestroyDirectoryDatabase(origin_url, type))
-    return false;
-  FilePath dest_root = GetDirectoryForOriginAndType(origin_url, type, true);
-  if (dest_root.empty())
-    return false;
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
-      origin_url, type, true);
-  if (!db)
-    return false;
-
-  file_util::FileEnumerator file_enum(src_root, true,
-      static_cast<file_util::FileEnumerator::FileType>(
-          file_util::FileEnumerator::FILES |
-          file_util::FileEnumerator::DIRECTORIES));
-  FilePath src_full_path;
-  size_t root_path_length = src_root.value().length() + 1;  // +1 for the slash
-  while (!(src_full_path = file_enum.Next()).empty()) {
-    file_util::FileEnumerator::FindInfo info;
-    file_enum.GetFindInfo(&info);
-    FilePath relative_virtual_path =
-        FilePath(src_full_path.value().substr(root_path_length));
-    if (relative_virtual_path.empty()) {
-      LOG(WARNING) << "Failed to convert path to relative: " <<
-          src_full_path.value();
-      return false;
-    }
-    FileId file_id;
-    if (db->GetFileWithPath(relative_virtual_path, &file_id)) {
-      NOTREACHED();  // File already exists.
-      return false;
-    }
-    if (!db->GetFileWithPath(relative_virtual_path.DirName(), &file_id)) {
-      NOTREACHED();  // Parent doesn't exist.
-      return false;
-    }
-
-    FileInfo file_info;
-    file_info.name = src_full_path.BaseName().value();
-    if (file_util::FileEnumerator::IsDirectory(info)) {
-#if defined(OS_WIN)
-      file_info.modification_time =
-          base::Time::FromFileTime(info.ftLastWriteTime);
-#elif defined(OS_POSIX)
-      file_info.modification_time = base::Time::FromTimeT(info.stat.st_mtime);
-#endif
-    } else {
-      file_info.data_path =
-          FilePath(kLegacyDataDirectory).Append(relative_virtual_path);
-    }
-    file_info.parent_id = file_id;
-    if (!db->AddFileInfo(file_info, &file_id)) {
-      NOTREACHED();
-      return false;
-    }
-  }
-  // TODO(ericu): Should we adjust the mtime of the root directory to match as
-  // well?
-  FilePath legacy_dest_dir = dest_root.Append(kLegacyDataDirectory);
-
-  if (!file_util::Move(src_root, legacy_dest_dir)) {
-    LOG(WARNING) <<
-        "The final step of a migration failed; I'll try to clean up.";
-    db = NULL;
-    DestroyDirectoryDatabase(origin_url, type);
-    return false;
-  }
-  return true;
-}
-
-// static
-FilePath::StringType ObfuscatedFileSystemFileUtil::GetDirectoryNameForType(
-    FileSystemType type) {
-  switch (type) {
-    case kFileSystemTypeTemporary:
-      return kTemporaryDirectoryName;
-    case kFileSystemTypePersistent:
-      return kPersistentDirectoryName;
-    case kFileSystemTypeUnknown:
-    default:
-      return FilePath::StringType();
-  }
-}
-
-FilePath ObfuscatedFileSystemFileUtil::DataPathToLocalPath(
+FilePath ObfuscatedFileUtil::DataPathToLocalPath(
     const GURL& origin, FileSystemType type, const FilePath& data_path) {
   FilePath root = GetDirectoryForOriginAndType(origin, type, false);
   if (root.empty())
@@ -1118,7 +1148,7 @@ FilePath ObfuscatedFileSystemFileUtil::DataPathToLocalPath(
   return root.Append(data_path);
 }
 
-FilePath ObfuscatedFileSystemFileUtil::LocalPathToDataPath(
+FilePath ObfuscatedFileUtil::LocalPathToDataPath(
     const GURL& origin, FileSystemType type, const FilePath& local_path) {
   FilePath root = GetDirectoryForOriginAndType(origin, type, false);
   if (root.empty())
@@ -1131,7 +1161,7 @@ FilePath ObfuscatedFileSystemFileUtil::LocalPathToDataPath(
 // TODO: How to do the whole validation-without-creation thing?  We may not have
 // quota even to create the database.  Ah, in that case don't even get here?
 // Still doesn't answer the quota issue, though.
-FileSystemDirectoryDatabase* ObfuscatedFileSystemFileUtil::GetDirectoryDatabase(
+FileSystemDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     const GURL& origin, FileSystemType type, bool create) {
   std::string type_string =
       FileSystemPathManager::GetFileSystemTypeString(type);
@@ -1162,7 +1192,7 @@ FileSystemDirectoryDatabase* ObfuscatedFileSystemFileUtil::GetDirectoryDatabase(
   return database;
 }
 
-FilePath ObfuscatedFileSystemFileUtil::GetDirectoryForOrigin(
+FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create) {
   if (!InitOriginDatabase(create))
     return FilePath();
@@ -1191,52 +1221,22 @@ FilePath ObfuscatedFileSystemFileUtil::GetDirectoryForOrigin(
   return path;
 }
 
-void ObfuscatedFileSystemFileUtil::MarkUsed() {
+void ObfuscatedFileUtil::MarkUsed() {
   if (timer_.IsRunning())
     timer_.Reset();
   else
     timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(kFlushDelaySeconds),
-                 this, &ObfuscatedFileSystemFileUtil::DropDatabases);
+                 this, &ObfuscatedFileUtil::DropDatabases);
 }
 
-void ObfuscatedFileSystemFileUtil::DropDatabases() {
+void ObfuscatedFileUtil::DropDatabases() {
   origin_database_.reset();
   STLDeleteContainerPairSecondPointers(
       directories_.begin(), directories_.end());
   directories_.clear();
 }
 
-// static
-int64 ObfuscatedFileSystemFileUtil::ComputeFilePathCost(const FilePath& path) {
-  return GetPathQuotaUsage(1, path.BaseName().value().size());
-}
-
-bool ObfuscatedFileSystemFileUtil::DestroyDirectoryDatabase(
-    const GURL& origin, FileSystemType type) {
-  std::string type_string =
-      FileSystemPathManager::GetFileSystemTypeString(type);
-  if (type_string.empty()) {
-    LOG(WARNING) << "Unknown filesystem type requested:" << type;
-    return true;
-  }
-  std::string key = GetOriginIdentifierFromURL(origin) + type_string;
-  DirectoryMap::iterator iter = directories_.find(key);
-  if (iter != directories_.end()) {
-    FileSystemDirectoryDatabase* database = iter->second;
-    directories_.erase(iter);
-    delete database;
-  }
-
-  FilePath path = GetDirectoryForOriginAndType(origin, type, false);
-  if (path.empty())
-    return true;
-  if (!file_util::DirectoryExists(path))
-    return true;
-  path = path.AppendASCII(kDirectoryDatabaseName);
-  return FileSystemDirectoryDatabase::DestroyDatabase(path);
-}
-
-bool ObfuscatedFileSystemFileUtil::InitOriginDatabase(bool create) {
+bool ObfuscatedFileUtil::InitOriginDatabase(bool create) {
   if (!origin_database_.get()) {
     if (!create && !file_util::DirectoryExists(file_system_directory_))
       return false;
diff --git a/webkit/fileapi/obfuscated_file_system_file_util.h b/webkit/fileapi/obfuscated_file_util.h
index 782fc07..c814b53 100644
--- a/webkit/fileapi/obfuscated_file_system_file_util.h
+++ b/webkit/fileapi/obfuscated_file_util.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_FILEAPI_OBFUSCATED_FILE_SYSTEM_FILE_UTIL_H_
-#define WEBKIT_FILEAPI_OBFUSCATED_FILE_SYSTEM_FILE_UTIL_H_
+#ifndef WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_
+#define WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 
 #include <map>
 #include <string>
@@ -45,17 +45,29 @@ class FileSystemOperationContext;
 //
 // TODO(ericu): We don't ever update directory mtimes; which operations should
 // do that?
-class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
-    public base::RefCountedThreadSafe<ObfuscatedFileSystemFileUtil> {
+class ObfuscatedFileUtil : public FileSystemFileUtil,
+    public base::RefCountedThreadSafe<ObfuscatedFileUtil> {
  public:
+  // Origin enumerator interface.
+  // An instance of this interface is assumed to be called on the file thread.
+  class AbstractOriginEnumerator {
+   public:
+    virtual ~AbstractOriginEnumerator() {}
+
+    // Returns the next origin.  Returns empty if there are no more origins.
+    virtual GURL Next() = 0;
+
+    // Returns the current origin's information.
+    virtual bool HasFileSystemType(FileSystemType type) const = 0;
+  };
+
   // |underlying_file_util| is owned by the instance.  It will be deleted by
   // the owner instance.  For example, it can be instanciated as follows:
-  // FileSystemFileUtil* file_system_file_util =
-  //     new ObfuscatedFileSystemFileUtil(new FileSystemFileUtil());
-  ObfuscatedFileSystemFileUtil(
-      const FilePath& file_system_directory,
-      FileSystemFileUtil* underlying_file_util);
-  virtual ~ObfuscatedFileSystemFileUtil();
+  // FileSystemFileUtil* file_util =
+  //     new ObfuscatedFileUtil(new NativeFileUtil());
+  ObfuscatedFileUtil(const FilePath& file_system_directory,
+                     FileSystemFileUtil* underlying_file_util);
+  virtual ~ObfuscatedFileUtil();
 
   virtual base::PlatformFileError CreateOrOpen(
       FileSystemOperationContext* context,
@@ -68,10 +80,11 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
       FileSystemOperationContext* context,
       const FilePath& file_path, bool* created) OVERRIDE;
 
-  virtual base::PlatformFileError GetLocalFilePath(
+  virtual base::PlatformFileError CreateDirectory(
       FileSystemOperationContext* context,
-      const FilePath& virtual_file,
-      FilePath* local_path) OVERRIDE;
+      const FilePath& file_path,
+      bool exclusive,
+      bool recursive) OVERRIDE;
 
   virtual base::PlatformFileError GetFileInfo(
       FileSystemOperationContext* context,
@@ -84,30 +97,14 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
       const FilePath& file_path,
       std::vector<base::FileUtilProxy::Entry>* entries) OVERRIDE;
 
-  virtual base::PlatformFileError CreateDirectory(
-      FileSystemOperationContext* context,
-      const FilePath& file_path,
-      bool exclusive,
-      bool recursive) OVERRIDE;
-
-  virtual base::PlatformFileError CopyOrMoveFile(
-      FileSystemOperationContext* context,
-      const FilePath& src_file_path,
-      const FilePath& dest_file_path,
-      bool copy) OVERRIDE;
-
-  virtual PlatformFileError CopyInForeignFile(
-        FileSystemOperationContext* context,
-        const FilePath& src_file_path,
-        const FilePath& dest_file_path) OVERRIDE;
-
-  virtual base::PlatformFileError DeleteFile(
+  virtual AbstractFileEnumerator* CreateFileEnumerator(
       FileSystemOperationContext* context,
-      const FilePath& file_path) OVERRIDE;
+      const FilePath& root_path) OVERRIDE;
 
-  virtual base::PlatformFileError DeleteSingleDirectory(
+  virtual base::PlatformFileError GetLocalFilePath(
       FileSystemOperationContext* context,
-      const FilePath& file_path) OVERRIDE;
+      const FilePath& virtual_file,
+      FilePath* local_path) OVERRIDE;
 
   virtual base::PlatformFileError Touch(
       FileSystemOperationContext* context,
@@ -132,6 +129,25 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
       FileSystemOperationContext* context,
       const FilePath& file_path) OVERRIDE;
 
+  virtual base::PlatformFileError CopyOrMoveFile(
+      FileSystemOperationContext* context,
+      const FilePath& src_file_path,
+      const FilePath& dest_file_path,
+      bool copy) OVERRIDE;
+
+  virtual PlatformFileError CopyInForeignFile(
+        FileSystemOperationContext* context,
+        const FilePath& src_file_path,
+        const FilePath& dest_file_path) OVERRIDE;
+
+  virtual base::PlatformFileError DeleteFile(
+      FileSystemOperationContext* context,
+      const FilePath& file_path) OVERRIDE;
+
+  virtual base::PlatformFileError DeleteSingleDirectory(
+      FileSystemOperationContext* context,
+      const FilePath& file_path) OVERRIDE;
+
   // Gets the topmost directory specific to this origin and type.  This will
   // contain both the directory database's files and all the backing file
   // subdirectories.
@@ -160,28 +176,11 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
   // SandboxMountPointProvider would be better?
   static FilePath::StringType GetDirectoryNameForType(FileSystemType type);
 
-  // Origin enumerator interface.
-  // An instance of this interface is assumed to be called on the file thread.
-  class AbstractOriginEnumerator {
-   public:
-    virtual ~AbstractOriginEnumerator() {}
-
-    // Returns the next origin.  Returns empty if there are no more origins.
-    virtual GURL Next() = 0;
-
-    // Returns the current origin's information.
-    virtual bool HasFileSystemType(FileSystemType type) const = 0;
-  };
-
   // This method and all methods of its returned class must be called only on
   // the FILE thread.  The caller is responsible for deleting the returned
   // object.
   AbstractOriginEnumerator* CreateOriginEnumerator();
 
-  virtual AbstractFileEnumerator* CreateFileEnumerator(
-      FileSystemOperationContext* context,
-      const FilePath& root_path) OVERRIDE;
-
   // Deletes a directory database from the database list in the ObfuscatedFSFU
   // and destroys the database on the disk.
   bool DestroyDirectoryDatabase(const GURL& origin, FileSystemType type);
@@ -221,6 +220,7 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
       const GURL& origin_url, FileSystemType type,
       const FilePath& source_path, FileInfo* file_info,
       int file_flags, base::PlatformFile* handle);
+
   // Given the filesystem's root URL and a virtual path, produces a real, full
   // local path to the underlying data file.  This does a database lookup, and
   // verifies that the file exists.
@@ -228,23 +228,28 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
       const GURL& origin_url,
       FileSystemType type,
       const FilePath& virtual_path);
+
   // This converts from a relative path [as is stored in the FileInfo.data_path
   // field] to an absolute local path that can be given to the operating system.
   // It does no checks as to whether the file actually exists; it's pure path
   // manipulation.
   FilePath DataPathToLocalPath(
       const GURL& origin, FileSystemType type, const FilePath& data_path);
+
   // This does the reverse of DataPathToLocalPath.
   FilePath LocalPathToDataPath(
       const GURL& origin, FileSystemType type, const FilePath& local_path);
+
   // This returns NULL if |create| flag is false and a filesystem does not
   // exist for the given |origin_url| and |type|.
   // For read operations |create| should be false.
   FileSystemDirectoryDatabase* GetDirectoryDatabase(
       const GURL& origin_url, FileSystemType type, bool create);
+
   // Gets the topmost directory specific to this origin.  This will
   // contain both the filesystem type subdirectories.
   FilePath GetDirectoryForOrigin(const GURL& origin, bool create);
+
   void MarkUsed();
   void DropDatabases();
   bool InitOriginDatabase(bool create);
@@ -253,12 +258,11 @@ class ObfuscatedFileSystemFileUtil : public FileSystemFileUtil,
   DirectoryMap directories_;
   scoped_ptr<FileSystemOriginDatabase> origin_database_;
   FilePath file_system_directory_;
-  base::OneShotTimer<ObfuscatedFileSystemFileUtil> timer_;
-  scoped_ptr<FileSystemFileUtil> underlying_file_util_;
+  base::OneShotTimer<ObfuscatedFileUtil> timer_;
 
-  DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileSystemFileUtil);
+  DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtil);
 };
 
 }  // namespace fileapi
 
-#endif  // WEBKIT_FILEAPI_OBFUSCATED_FILE_SYSTEM_FILE_UTIL_H_
+#endif  // WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_
diff --git a/webkit/fileapi/obfuscated_file_system_file_util_unittest.cc b/webkit/fileapi/obfuscated_file_util_unittest.cc
index 879338f..ec40c67 100644
--- a/webkit/fileapi/obfuscated_file_system_file_util_unittest.cc
+++ b/webkit/fileapi/obfuscated_file_util_unittest.cc
@@ -20,7 +20,7 @@
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_test_helper.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
-#include "webkit/fileapi/obfuscated_file_system_file_util.h"
+#include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/quota/mock_special_storage_policy.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
@@ -128,9 +128,9 @@ const OriginEnumerationTestRecord kOriginEnumerationTestRecords[] = {
 // could theoretically be shared.  It would basically be a FSFU interface
 // compliance test, and only the subclass-specific bits that look into the
 // implementation would need to be written per-subclass.
-class ObfuscatedFileSystemFileUtilTest : public testing::Test {
+class ObfuscatedFileUtilTest : public testing::Test {
  public:
-  ObfuscatedFileSystemFileUtilTest()
+  ObfuscatedFileUtilTest()
       : origin_(GURL("http://www.example.com")),
         type_(kFileSystemTypeTemporary),
         callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
@@ -151,7 +151,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
 
     // Every time we create a new helper, it creates another context, which
     // creates another path manager, another sandbox_mount_point_provider, and
-    // another OFSFU.  We need to pass in the context to skip all that.
+    // another OFU.  We need to pass in the context to skip all that.
     file_system_context_ = new FileSystemContext(
         base::MessageLoopProxy::current(),
         base::MessageLoopProxy::current(),
@@ -163,13 +163,11 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
         false /* unlimited_quota */,
         NULL /* path_manager */);
 
-    obfuscated_file_system_file_util_ =
-        static_cast<ObfuscatedFileSystemFileUtil*>(
-            file_system_context_->path_manager()->GetFileSystemFileUtil(type_));
-
+    obfuscated_file_util_ = static_cast<ObfuscatedFileUtil*>(
+        file_system_context_->path_manager()->GetFileUtil(type_));
 
     test_helper_.SetUp(file_system_context_.get(),
-                       obfuscated_file_system_file_util_.get());
+                       obfuscated_file_util_.get());
   }
 
   FileSystemOperationContext* NewContext(FileSystemTestOriginHelper* helper) {
@@ -183,7 +181,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
   }
 
   // This can only be used after SetUp has run and created file_system_context_
-  // and obfuscated_file_system_file_util_.
+  // and obfuscated_file_util_.
   // Use this for tests which need to run in multiple origins; we need a test
   // helper per origin.
   FileSystemTestOriginHelper* NewHelper(
@@ -192,12 +190,12 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
         new FileSystemTestOriginHelper(origin, type);
 
     helper->SetUp(file_system_context_.get(),
-                  obfuscated_file_system_file_util_.get());
+                  obfuscated_file_util_.get());
     return helper;
   }
 
-  ObfuscatedFileSystemFileUtil* ofsfu() {
-    return obfuscated_file_system_file_util_.get();
+  ObfuscatedFileUtil* ofu() {
+    return obfuscated_file_util_.get();
   }
 
   const FilePath& test_directory() const {
@@ -216,7 +214,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     quota_manager_->GetUsageAndQuota(
       origin(), test_helper_.storage_type(),
       callback_factory_.NewCallback(
-          &ObfuscatedFileSystemFileUtilTest::OnGetUsage));
+          &ObfuscatedFileUtilTest::OnGetUsage));
     MessageLoop::current()->RunAllPending();
     EXPECT_EQ(quota::kQuotaStatusOk, quota_status_);
   }
@@ -242,12 +240,12 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
       const FilePath& virtual_path, PlatformFile file_handle) {
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     FilePath local_path;
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetLocalFilePath(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
         context.get(), virtual_path, &local_path));
 
     base::PlatformFileInfo file_info0;
     FilePath data_path;
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), virtual_path, &file_info0, &data_path));
     EXPECT_EQ(data_path, local_path);
     EXPECT_TRUE(FileExists(data_path));
@@ -274,7 +272,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     base::PlatformFileInfo file_info1;
     EXPECT_EQ(length, GetSize(data_path));
     context.reset(NewContext(NULL));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), virtual_path, &file_info1, &data_path));
     EXPECT_EQ(data_path, local_path);
 
@@ -287,12 +285,12 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     EXPECT_LE(file_info0.last_modified, file_info1.last_modified);
 
     context.reset(NewContext(NULL));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->Truncate(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
         context.get(), virtual_path, length * 2));
     EXPECT_EQ(length * 2, GetSize(data_path));
 
     context.reset(NewContext(NULL));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->Truncate(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
         context.get(), virtual_path, 0));
     EXPECT_EQ(0, GetSize(data_path));
   }
@@ -307,14 +305,14 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
       bool created = true;
       context.reset(NewContext(NULL));
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-          ofsfu()->EnsureFileExists(
+          ofu()->EnsureFileExists(
               context.get(), root_path.Append(*iter),
               &created));
       ASSERT_FALSE(created);
     }
     for (iter = directories.begin(); iter != directories.end(); ++iter) {
       context.reset(NewContext(NULL));
-      EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(),
+      EXPECT_TRUE(ofu()->DirectoryExists(context.get(),
           root_path.Append(*iter)));
     }
   }
@@ -327,7 +325,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     context.reset(NewContext(NULL));
     std::vector<base::FileUtilProxy::Entry> entries;
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-        ofsfu()->ReadDirectory(context.get(), root_path, &entries));
+        ofu()->ReadDirectory(context.get(), root_path, &entries));
     EXPECT_EQ(0UL, entries.size());
 
     files->clear();
@@ -343,7 +341,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
       bool created = false;
       context.reset(NewContext(NULL));
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-          ofsfu()->EnsureFileExists(
+          ofu()->EnsureFileExists(
               context.get(), root_path.Append(*iter), &created));
       ASSERT_TRUE(created);
     }
@@ -352,7 +350,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
       bool recursive = false;
       context.reset(NewContext(NULL));
       EXPECT_EQ(base::PLATFORM_FILE_OK,
-          ofsfu()->CreateDirectory(
+          ofu()->CreateDirectory(
               context.get(), root_path.Append(*iter), exclusive, recursive));
     }
     ValidateTestDirectory(root_path, *files, *directories);
@@ -367,7 +365,7 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     std::vector<base::FileUtilProxy::Entry> entries;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-        ofsfu()->ReadDirectory(context.get(), root_path, &entries));
+        ofu()->ReadDirectory(context.get(), root_path, &entries));
     std::vector<base::FileUtilProxy::Entry>::iterator entry_iter;
     EXPECT_EQ(files.size() + directories.size(), entries.size());
     for (entry_iter = entries.begin(); entry_iter != entries.end();
@@ -392,12 +390,12 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
 
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              ofsfu()->Touch(
+              ofu()->Touch(
                   context.get(), path, last_access_time, last_modified_time));
     FilePath local_path;
     base::PlatformFileInfo file_info;
     context.reset(NewContext(NULL));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), path, &file_info, &local_path));
     // We compare as time_t here to lower our resolution, to avoid false
     // negatives caused by conversion to the local filesystem's native
@@ -408,13 +406,13 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     last_modified_time += base::TimeDelta::FromHours(1);
     last_access_time += base::TimeDelta::FromHours(14);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              ofsfu()->Touch(
+              ofu()->Touch(
                   context.get(), path, last_access_time, last_modified_time));
     context.reset(NewContext(NULL));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), path, &file_info, &local_path));
     EXPECT_EQ(file_info.last_modified.ToTimeT(), last_modified_time.ToTimeT());
-    if (is_file)  // Directories in OFSFU don't support atime.
+    if (is_file)  // Directories in OFU don't support atime.
       EXPECT_EQ(file_info.last_accessed.ToTimeT(), last_access_time.ToTimeT());
   }
 
@@ -443,59 +441,59 @@ class ObfuscatedFileSystemFileUtilTest : public testing::Test {
     if (overwrite) {
       context.reset(NewContext(NULL));
       EXPECT_EQ(base::PLATFORM_FILE_OK,
-          ofsfu()->EnsureFileExists(context.get(), dest_path, &created));
+          ofu()->EnsureFileExists(context.get(), dest_path, &created));
       EXPECT_TRUE(created);
     }
 
     const int64 path_cost =
-        ObfuscatedFileSystemFileUtil::ComputeFilePathCost(dest_path);
+        ObfuscatedFileUtil::ComputeFilePathCost(dest_path);
     if (!overwrite) {
       // Verify that file creation requires sufficient quota for the path.
       context.reset(NewContext(NULL));
       context->set_allowed_bytes_growth(path_cost + src_file_length - 1);
       EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE,
-          ofsfu()->CopyInForeignFile(context.get(), src_path, dest_path));
+          ofu()->CopyInForeignFile(context.get(), src_path, dest_path));
     }
 
     context.reset(NewContext(NULL));
     context->set_allowed_bytes_growth(path_cost + src_file_length);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-        ofsfu()->CopyInForeignFile(context.get(), src_path, dest_path));
+        ofu()->CopyInForeignFile(context.get(), src_path, dest_path));
 
     context.reset(NewContext(NULL));
-    EXPECT_TRUE(ofsfu()->PathExists(context.get(), dest_path));
+    EXPECT_TRUE(ofu()->PathExists(context.get(), dest_path));
     context.reset(NewContext(NULL));
-    EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), dest_path));
+    EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_path));
     context.reset(NewContext(NULL));
     base::PlatformFileInfo file_info;
     FilePath data_path;
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), dest_path, &file_info, &data_path));
     EXPECT_NE(data_path, src_path);
     EXPECT_TRUE(FileExists(data_path));
     EXPECT_EQ(src_file_length, GetSize(data_path));
 
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-        ofsfu()->DeleteFile(context.get(), dest_path));
+        ofu()->DeleteFile(context.get(), dest_path));
   }
 
  private:
   ScopedTempDir data_dir_;
-  scoped_refptr<ObfuscatedFileSystemFileUtil> obfuscated_file_system_file_util_;
+  scoped_refptr<ObfuscatedFileUtil> obfuscated_file_util_;
   scoped_refptr<quota::QuotaManager> quota_manager_;
   scoped_refptr<FileSystemContext> file_system_context_;
   GURL origin_;
   fileapi::FileSystemType type_;
-  base::ScopedCallbackFactory<ObfuscatedFileSystemFileUtilTest>
+  base::ScopedCallbackFactory<ObfuscatedFileUtilTest>
       callback_factory_;
   FileSystemTestOriginHelper test_helper_;
   quota::QuotaStatusCode quota_status_;
   int64 usage_;
 
-  DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileSystemFileUtilTest);
+  DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtilTest);
 };
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
+TEST_F(ObfuscatedFileUtilTest, TestCreateAndDeleteFile) {
   base::PlatformFile file_handle = base::kInvalidPlatformFileValue;
   bool created;
   FilePath path = UTF8ToFilePath("fake/file");
@@ -503,29 +501,29 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
   int file_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE;
 
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            ofsfu()->CreateOrOpen(
+            ofu()->CreateOrOpen(
                 context.get(), path, file_flags, &file_handle,
                 &created));
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            ofsfu()->DeleteFile(context.get(), path));
+            ofu()->DeleteFile(context.get(), path));
 
   path = UTF8ToFilePath("test file");
 
   // Verify that file creation requires sufficient quota for the path.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path) - 1);
+      ObfuscatedFileUtil::ComputeFilePathCost(path) - 1);
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE,
-            ofsfu()->CreateOrOpen(
+            ofu()->CreateOrOpen(
                 context.get(), path, file_flags, &file_handle, &created));
 
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path));
+      ObfuscatedFileUtil::ComputeFilePathCost(path));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->CreateOrOpen(
+            ofu()->CreateOrOpen(
                 context.get(), path, file_flags, &file_handle, &created));
   ASSERT_TRUE(created);
   EXPECT_NE(base::kInvalidPlatformFileValue, file_handle);
@@ -534,7 +532,7 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
 
   context.reset(NewContext(NULL));
   FilePath local_path;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetLocalFilePath(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
       context.get(), path, &local_path));
   EXPECT_TRUE(file_util::PathExists(local_path));
 
@@ -543,9 +541,9 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(0);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->DeleteFile(context.get(), path));
+            ofu()->DeleteFile(context.get(), path));
   EXPECT_FALSE(file_util::PathExists(local_path));
-  EXPECT_EQ(ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path),
+  EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(path),
       context->allowed_bytes_growth());
 
   context.reset(NewContext(NULL));
@@ -553,13 +551,13 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
   bool recursive = true;
   FilePath directory_path = UTF8ToFilePath("series/of/directories");
   path = directory_path.AppendASCII("file name");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), directory_path, exclusive, recursive));
 
   context.reset(NewContext(NULL));
   file_handle = base::kInvalidPlatformFileValue;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->CreateOrOpen(
+            ofu()->CreateOrOpen(
                 context.get(), path, file_flags, &file_handle, &created));
   ASSERT_TRUE(created);
   EXPECT_NE(base::kInvalidPlatformFileValue, file_handle);
@@ -567,57 +565,57 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestCreateAndDeleteFile) {
   CheckFileAndCloseHandle(path, file_handle);
 
   context.reset(NewContext(NULL));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetLocalFilePath(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
       context.get(), path, &local_path));
   EXPECT_TRUE(file_util::PathExists(local_path));
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->DeleteFile(context.get(), path));
+            ofu()->DeleteFile(context.get(), path));
   EXPECT_FALSE(file_util::PathExists(local_path));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestTruncate) {
+TEST_F(ObfuscatedFileUtilTest, TestTruncate) {
   bool created = false;
   FilePath path = UTF8ToFilePath("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            ofsfu()->Truncate(context.get(), path, 4));
+            ofu()->Truncate(context.get(), path, 4));
 
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->EnsureFileExists(context.get(), path, &created));
+      ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_TRUE(created);
 
   context.reset(NewContext(NULL));
   FilePath local_path;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetLocalFilePath(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetLocalFilePath(
       context.get(), path, &local_path));
   EXPECT_EQ(0, GetSize(local_path));
 
   context.reset(NewContext(NULL));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->Truncate(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
       context.get(), path, 10));
   EXPECT_EQ(10, GetSize(local_path));
 
   context.reset(NewContext(NULL));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->Truncate(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->Truncate(
       context.get(), path, 1));
   EXPECT_EQ(1, GetSize(local_path));
 
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_TRUE(ofu()->PathExists(context.get(), path));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestEnsureFileExists) {
+TEST_F(ObfuscatedFileUtilTest, TestEnsureFileExists) {
   FilePath path = UTF8ToFilePath("fake/file");
   bool created = false;
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            ofsfu()->EnsureFileExists(
+            ofu()->EnsureFileExists(
                 context.get(), path, &created));
 
   // Verify that file creation requires sufficient quota for the path.
@@ -625,23 +623,23 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestEnsureFileExists) {
   path = UTF8ToFilePath("test file");
   created = false;
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path) - 1);
+      ObfuscatedFileUtil::ComputeFilePathCost(path) - 1);
   ASSERT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE,
-            ofsfu()->EnsureFileExists(context.get(), path, &created));
+            ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_FALSE(created);
 
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path));
+      ObfuscatedFileUtil::ComputeFilePathCost(path));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), path, &created));
+            ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_TRUE(created);
 
   CheckFileAndCloseHandle(path, base::kInvalidPlatformFileValue);
 
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), path, &created));
+            ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_FALSE(created);
 
   // Also test in a subdirectory.
@@ -649,65 +647,65 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestEnsureFileExists) {
   context.reset(NewContext(NULL));
   bool exclusive = true;
   bool recursive = true;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path.DirName(), exclusive, recursive));
 
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), path, &created));
+            ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_TRUE(created);
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_TRUE(ofu()->PathExists(context.get(), path));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestDirectoryOps) {
+TEST_F(ObfuscatedFileUtilTest, TestDirectoryOps) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool exclusive = false;
   bool recursive = false;
   FilePath path = UTF8ToFilePath("foo/bar");
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-      ofsfu()->DeleteSingleDirectory(context.get(), path));
+      ofu()->DeleteSingleDirectory(context.get(), path));
 
   FilePath root = UTF8ToFilePath("");
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_FALSE(ofu()->PathExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->IsDirectoryEmpty(context.get(), root));
+  EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), root));
 
   context.reset(NewContext(NULL));
   exclusive = false;
   recursive = true;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_TRUE(ofu()->PathExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->IsDirectoryEmpty(context.get(), root));
+  EXPECT_FALSE(ofu()->IsDirectoryEmpty(context.get(), root));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(), path.DirName()));
+  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), path.DirName()));
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->IsDirectoryEmpty(context.get(), path.DirName()));
+  EXPECT_FALSE(ofu()->IsDirectoryEmpty(context.get(), path.DirName()));
 
   // Can't remove a non-empty directory.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_EMPTY,
-      ofsfu()->DeleteSingleDirectory(context.get(), path.DirName()));
+      ofu()->DeleteSingleDirectory(context.get(), path.DirName()));
 
   base::PlatformFileInfo file_info;
   FilePath local_path;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
       context.get(), path, &file_info, &local_path));
   EXPECT_TRUE(local_path.empty());
   EXPECT_TRUE(file_info.is_directory);
@@ -715,13 +713,13 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestDirectoryOps) {
 
   // Same create again should succeed, since exclusive is false.
   context.reset(NewContext(NULL));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   exclusive = true;
   recursive = true;
   context.reset(NewContext(NULL));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   // Verify that deleting a directory isn't stopped by zero quota, and that it
@@ -729,19 +727,19 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestDirectoryOps) {
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(0);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->DeleteSingleDirectory(context.get(), path));
-  EXPECT_EQ(ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path),
+      ofu()->DeleteSingleDirectory(context.get(), path));
+  EXPECT_EQ(ObfuscatedFileUtil::ComputeFilePathCost(path),
       context->allowed_bytes_growth());
 
   path = UTF8ToFilePath("foo/bop");
 
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_FALSE(ofu()->PathExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->IsDirectoryEmpty(context.get(), path));
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofsfu()->GetFileInfo(
+  EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), path));
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->GetFileInfo(
       context.get(), path, &file_info, &local_path));
 
   // Verify that file creation requires sufficient quota for the path.
@@ -749,91 +747,91 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestDirectoryOps) {
   recursive = false;
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path) - 1);
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofsfu()->CreateDirectory(
+      ObfuscatedFileUtil::ComputeFilePathCost(path) - 1);
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path));
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+      ObfuscatedFileUtil::ComputeFilePathCost(path));
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_TRUE(ofu()->PathExists(context.get(), path));
 
   exclusive = true;
   recursive = false;
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   exclusive = true;
   recursive = false;
   path = UTF8ToFilePath("foo");
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   path = UTF8ToFilePath("blah");
 
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_FALSE(ofu()->PathExists(context.get(), path));
 
   exclusive = true;
   recursive = false;
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(), path));
+  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->PathExists(context.get(), path));
+  EXPECT_TRUE(ofu()->PathExists(context.get(), path));
 
   exclusive = true;
   recursive = false;
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestReadDirectory) {
+TEST_F(ObfuscatedFileUtilTest, TestReadDirectory) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   bool exclusive = true;
   bool recursive = true;
   FilePath path = UTF8ToFilePath("directory/to/use");
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
   TestReadDirectoryHelper(path);
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestReadRootWithSlash) {
+TEST_F(ObfuscatedFileUtilTest, TestReadRootWithSlash) {
   TestReadDirectoryHelper(UTF8ToFilePath(""));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestReadRootWithEmptyString) {
+TEST_F(ObfuscatedFileUtilTest, TestReadRootWithEmptyString) {
   TestReadDirectoryHelper(UTF8ToFilePath("/"));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestReadDirectoryOnFile) {
+TEST_F(ObfuscatedFileUtilTest, TestReadDirectoryOnFile) {
   FilePath path = UTF8ToFilePath("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool created = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->EnsureFileExists(context.get(), path, &created));
+      ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_TRUE(created);
 
   context.reset(NewContext(NULL));
   std::vector<base::FileUtilProxy::Entry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-      ofsfu()->ReadDirectory(context.get(), path, &entries));
+      ofu()->ReadDirectory(context.get(), path, &entries));
 
-  EXPECT_TRUE(ofsfu()->IsDirectoryEmpty(context.get(), path));
+  EXPECT_TRUE(ofu()->IsDirectoryEmpty(context.get(), path));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestTouch) {
+TEST_F(ObfuscatedFileUtilTest, TestTouch) {
   FilePath path = UTF8ToFilePath("file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
@@ -842,14 +840,14 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestTouch) {
 
   // It's not there yet.
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            ofsfu()->Touch(
+            ofu()->Touch(
                 context.get(), path, last_access_time, last_modified_time));
 
   // OK, now create it.
   context.reset(NewContext(NULL));
   bool created = false;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), path, &created));
+            ofu()->EnsureFileExists(context.get(), path, &created));
   ASSERT_TRUE(created);
   TestTouchHelper(path, true);
 
@@ -858,12 +856,12 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestTouch) {
   bool exclusive = true;
   bool recursive = false;
   path = UTF8ToFilePath("dir");
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(context.get(),
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(context.get(),
       path, exclusive, recursive));
   TestTouchHelper(path, false);
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestPathQuotas) {
+TEST_F(ObfuscatedFileUtilTest, TestPathQuotas) {
   FilePath path = UTF8ToFilePath("fake/file");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
@@ -871,15 +869,13 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestPathQuotas) {
   context->set_allowed_bytes_growth(5);
   bool created = false;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE,
-            ofsfu()->EnsureFileExists(
-                context.get(), path, &created));
+      ofu()->EnsureFileExists(context.get(), path, &created));
   EXPECT_FALSE(created);
   context->set_allowed_bytes_growth(1024);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(
-                context.get(), path, &created));
+      ofu()->EnsureFileExists(context.get(), path, &created));
   EXPECT_TRUE(created);
-  int64 path_cost = ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path);
+  int64 path_cost = ObfuscatedFileUtil::ComputeFilePathCost(path);
   EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth());
 
   context->set_allowed_bytes_growth(1024);
@@ -891,48 +887,48 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestPathQuotas) {
   path_cost = 0;
   for (std::vector<FilePath::StringType>::iterator iter = components.begin();
       iter != components.end(); ++iter) {
-    path_cost += ObfuscatedFileSystemFileUtil::ComputeFilePathCost(
+    path_cost += ObfuscatedFileUtil::ComputeFilePathCost(
         FilePath(*iter));
   }
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(1024);
-  EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), path, exclusive, recursive));
   EXPECT_EQ(1024 - path_cost, context->allowed_bytes_growth());
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestCopyOrMoveFileNotFound) {
+TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileNotFound) {
   FilePath source_path = UTF8ToFilePath("path0.txt");
   FilePath dest_path = UTF8ToFilePath("path1.txt");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   bool is_copy_not_move = false;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-      ofsfu()->CopyOrMoveFile(context.get(), source_path, dest_path,
+      ofu()->CopyOrMoveFile(context.get(), source_path, dest_path,
           is_copy_not_move));
   context.reset(NewContext(NULL));
   is_copy_not_move = true;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-      ofsfu()->CopyOrMoveFile(context.get(), source_path, dest_path,
+      ofu()->CopyOrMoveFile(context.get(), source_path, dest_path,
           is_copy_not_move));
   source_path = UTF8ToFilePath("dir/dir/file");
   bool exclusive = true;
   bool recursive = true;
   context.reset(NewContext(NULL));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), source_path.DirName(), exclusive, recursive));
   is_copy_not_move = false;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-      ofsfu()->CopyOrMoveFile(context.get(), source_path, dest_path,
+      ofu()->CopyOrMoveFile(context.get(), source_path, dest_path,
           is_copy_not_move));
   context.reset(NewContext(NULL));
   is_copy_not_move = true;
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-      ofsfu()->CopyOrMoveFile(context.get(), source_path, dest_path,
+      ofu()->CopyOrMoveFile(context.get(), source_path, dest_path,
           is_copy_not_move));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestCopyOrMoveFileSuccess) {
+TEST_F(ObfuscatedFileUtilTest, TestCopyOrMoveFileSuccess) {
   const int64 kSourceLength = 5;
   const int64 kDestLength = 50;
 
@@ -955,135 +951,135 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestCopyOrMoveFileSuccess) {
     FilePath dest_path = UTF8ToFilePath(test_case.dest_path);
 
     context.reset(NewContext(NULL));
-    ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+    ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
         context.get(), source_path.DirName(), exclusive, recursive));
     context.reset(NewContext(NULL));
-    ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+    ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
         context.get(), dest_path.DirName(), exclusive, recursive));
 
     bool created = false;
     context.reset(NewContext(NULL));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              ofsfu()->EnsureFileExists(context.get(), source_path, &created));
+              ofu()->EnsureFileExists(context.get(), source_path, &created));
     ASSERT_TRUE(created);
     context.reset(NewContext(NULL));
     ASSERT_EQ(base::PLATFORM_FILE_OK,
-              ofsfu()->Truncate(context.get(), source_path, kSourceLength));
+              ofu()->Truncate(context.get(), source_path, kSourceLength));
 
     if (test_case.cause_overwrite) {
       context.reset(NewContext(NULL));
       created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-                ofsfu()->EnsureFileExists(context.get(), dest_path, &created));
+                ofu()->EnsureFileExists(context.get(), dest_path, &created));
       ASSERT_TRUE(created);
       context.reset(NewContext(NULL));
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-                ofsfu()->Truncate(context.get(), dest_path, kDestLength));
+                ofu()->Truncate(context.get(), dest_path, kDestLength));
     }
 
     context.reset(NewContext(NULL));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CopyOrMoveFile(context.get(),
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->CopyOrMoveFile(context.get(),
         source_path, dest_path, test_case.is_copy_not_move));
     if (test_case.is_copy_not_move) {
       base::PlatformFileInfo file_info;
       FilePath local_path;
       context.reset(NewContext(NULL));
-      EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+      EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
           context.get(), source_path, &file_info, &local_path));
       EXPECT_EQ(kSourceLength, file_info.size);
       EXPECT_EQ(base::PLATFORM_FILE_OK,
-                ofsfu()->DeleteFile(context.get(), source_path));
+                ofu()->DeleteFile(context.get(), source_path));
     } else {
       base::PlatformFileInfo file_info;
       FilePath local_path;
       context.reset(NewContext(NULL));
-      EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofsfu()->GetFileInfo(
+      EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, ofu()->GetFileInfo(
           context.get(), source_path, &file_info, &local_path));
     }
     base::PlatformFileInfo file_info;
     FilePath local_path;
-    EXPECT_EQ(base::PLATFORM_FILE_OK, ofsfu()->GetFileInfo(
+    EXPECT_EQ(base::PLATFORM_FILE_OK, ofu()->GetFileInfo(
         context.get(), dest_path, &file_info, &local_path));
     EXPECT_EQ(kSourceLength, file_info.size);
 
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              ofsfu()->DeleteFile(context.get(), dest_path));
+              ofu()->DeleteFile(context.get(), dest_path));
   }
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestCopyPathQuotas) {
+TEST_F(ObfuscatedFileUtilTest, TestCopyPathQuotas) {
   FilePath src_path = UTF8ToFilePath("src path");
   FilePath dest_path = UTF8ToFilePath("destination path");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->EnsureFileExists(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(
       context.get(), src_path, &created));
 
   bool is_copy = true;
   // Copy, no overwrite.
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(dest_path) - 1);
+      ObfuscatedFileUtil::ComputeFilePathCost(dest_path) - 1);
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(dest_path));
+      ObfuscatedFileUtil::ComputeFilePathCost(dest_path));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
 
   // Copy, with overwrite.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(0);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestMovePathQuotasWithRename) {
+TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithRename) {
   FilePath src_path = UTF8ToFilePath("src path");
   FilePath dest_path = UTF8ToFilePath("destination path");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->EnsureFileExists(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(
       context.get(), src_path, &created));
 
   bool is_copy = false;
   // Move, rename, no overwrite.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(dest_path) -
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(src_path) - 1);
+      ObfuscatedFileUtil::ComputeFilePathCost(dest_path) -
+      ObfuscatedFileUtil::ComputeFilePathCost(src_path) - 1);
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NO_SPACE,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(dest_path) -
-      ObfuscatedFileSystemFileUtil::ComputeFilePathCost(src_path));
+      ObfuscatedFileUtil::ComputeFilePathCost(dest_path) -
+      ObfuscatedFileUtil::ComputeFilePathCost(src_path));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
 
   context.reset(NewContext(NULL));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->EnsureFileExists(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(
       context.get(), src_path, &created));
 
   // Move, rename, with overwrite.
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(0);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestMovePathQuotasWithoutRename) {
+TEST_F(ObfuscatedFileUtilTest, TestMovePathQuotasWithoutRename) {
   FilePath src_path = UTF8ToFilePath("src path");
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   bool created = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->EnsureFileExists(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(
       context.get(), src_path, &created));
 
   bool exclusive = true;
   bool recursive = false;
   FilePath dir_path = UTF8ToFilePath("directory path");
   context.reset(NewContext(NULL));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), dir_path, exclusive, recursive));
 
   FilePath dest_path = dir_path.Append(src_path);
@@ -1094,34 +1090,34 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestMovePathQuotasWithoutRename) {
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(allowed_bytes_growth);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
   EXPECT_EQ(allowed_bytes_growth, context->allowed_bytes_growth());
 
   // Move, no rename, with overwrite.
   context.reset(NewContext(NULL));
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->EnsureFileExists(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->EnsureFileExists(
       context.get(), src_path, &created));
   context.reset(NewContext(NULL));
   context->set_allowed_bytes_growth(allowed_bytes_growth);
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
+      ofu()->CopyOrMoveFile(context.get(), src_path, dest_path, is_copy));
   EXPECT_EQ(
       allowed_bytes_growth +
-          ObfuscatedFileSystemFileUtil::ComputeFilePathCost(src_path),
+          ObfuscatedFileUtil::ComputeFilePathCost(src_path),
       context->allowed_bytes_growth());
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestCopyInForeignFile) {
+TEST_F(ObfuscatedFileUtilTest, TestCopyInForeignFile) {
   TestCopyInForeignFileHelper(false /* overwrite */);
   TestCopyInForeignFileHelper(true /* overwrite */);
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestEnumerator) {
+TEST_F(ObfuscatedFileUtilTest, TestEnumerator) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
   FilePath src_path = UTF8ToFilePath("source dir");
   bool exclusive = true;
   bool recursive = false;
-  ASSERT_EQ(base::PLATFORM_FILE_OK, ofsfu()->CreateDirectory(
+  ASSERT_EQ(base::PLATFORM_FILE_OK, ofu()->CreateDirectory(
       context.get(), src_path, exclusive, recursive));
 
   std::set<FilePath::StringType> files;
@@ -1131,25 +1127,25 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestEnumerator) {
   FilePath dest_path = UTF8ToFilePath("destination dir");
 
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), dest_path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_path));
   context.reset(NewContext(NULL));
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->Copy(context.get(), src_path, dest_path));
+      ofu()->Copy(context.get(), src_path, dest_path));
 
   ValidateTestDirectory(dest_path, files, directories);
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(), src_path));
+  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), src_path));
   context.reset(NewContext(NULL));
-  EXPECT_TRUE(ofsfu()->DirectoryExists(context.get(), dest_path));
+  EXPECT_TRUE(ofu()->DirectoryExists(context.get(), dest_path));
   context.reset(NewContext(NULL));
   recursive = true;
   ASSERT_EQ(base::PLATFORM_FILE_OK,
-      ofsfu()->Delete(context.get(), dest_path, recursive));
+      ofu()->Delete(context.get(), dest_path, recursive));
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->DirectoryExists(context.get(), dest_path));
+  EXPECT_FALSE(ofu()->DirectoryExists(context.get(), dest_path));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestMigration) {
+TEST_F(ObfuscatedFileUtilTest, TestMigration) {
   ScopedTempDir source_dir;
   ASSERT_TRUE(source_dir.CreateUniqueTempDir());
   FilePath root_path = source_dir.path().AppendASCII("chrome-pLmnMWXE7NzTFRsn");
@@ -1178,11 +1174,11 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestMigration) {
     }
   }
 
-  EXPECT_TRUE(ofsfu()->MigrateFromOldSandbox(origin(), type(), root_path));
+  EXPECT_TRUE(ofu()->MigrateFromOldSandbox(origin(), type(), root_path));
 
   FilePath new_root =
     test_directory().AppendASCII("File System").AppendASCII("000").Append(
-        ofsfu()->GetDirectoryNameForType(type())).AppendASCII("Legacy");
+        ofu()->GetDirectoryNameForType(type())).AppendASCII("Legacy");
   for (size_t i = 0; i < arraysize(kMigrationTestCases); ++i) {
     SCOPED_TRACE(testing::Message() << "Validating kMigrationTestPath " << i);
     const MigrationTestCaseRecord& test_case = kMigrationTestCases[i];
@@ -1191,14 +1187,14 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestMigration) {
     local_data_path = local_data_path.NormalizeWindowsPathSeparators();
 #endif
     scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
-    base::PlatformFileInfo ofsfu_file_info;
+    base::PlatformFileInfo ofu_file_info;
     FilePath data_path;
     SCOPED_TRACE(testing::Message() << "Path is " << test_case.path);
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-        ofsfu()->GetFileInfo(context.get(), FilePath(test_case.path),
-            &ofsfu_file_info, &data_path));
+        ofu()->GetFileInfo(context.get(), FilePath(test_case.path),
+            &ofu_file_info, &data_path));
     if (test_case.is_directory) {
-      EXPECT_TRUE(ofsfu_file_info.is_directory);
+      EXPECT_TRUE(ofu_file_info.is_directory);
     } else {
       base::PlatformFileInfo platform_file_info;
       SCOPED_TRACE(testing::Message() << "local_data_path is " <<
@@ -1209,15 +1205,15 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestMigration) {
       EXPECT_FALSE(platform_file_info.is_directory);
       scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
       EXPECT_EQ(local_data_path, data_path);
-      EXPECT_EQ(platform_file_info.size, ofsfu_file_info.size);
-      EXPECT_FALSE(ofsfu_file_info.is_directory);
+      EXPECT_EQ(platform_file_info.size, ofu_file_info.size);
+      EXPECT_FALSE(ofu_file_info.is_directory);
     }
   }
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestOriginEnumerator) {
-  scoped_ptr<ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator>
-      enumerator(ofsfu()->CreateOriginEnumerator());
+TEST_F(ObfuscatedFileUtilTest, TestOriginEnumerator) {
+  scoped_ptr<ObfuscatedFileUtil::AbstractOriginEnumerator>
+      enumerator(ofu()->CreateOriginEnumerator());
   // The test helper starts out with a single filesystem.
   EXPECT_TRUE(enumerator.get());
   EXPECT_EQ(origin(), enumerator->Next());
@@ -1246,7 +1242,7 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestOriginEnumerator) {
       context->set_src_type(kFileSystemTypeTemporary);
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-                ofsfu()->EnsureFileExists(context.get(),
+                ofu()->EnsureFileExists(context.get(),
                     FilePath().AppendASCII("file"), &created));
       EXPECT_TRUE(created);
     }
@@ -1258,12 +1254,12 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestOriginEnumerator) {
       context->set_src_type(kFileSystemTypePersistent);
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-                ofsfu()->EnsureFileExists(context.get(),
+                ofu()->EnsureFileExists(context.get(),
                     FilePath().AppendASCII("file"), &created));
       EXPECT_TRUE(created);
     }
   }
-  enumerator.reset(ofsfu()->CreateOriginEnumerator());
+  enumerator.reset(ofu()->CreateOriginEnumerator());
   EXPECT_TRUE(enumerator.get());
   std::set<GURL> origins_found;
   GURL origin_url;
@@ -1302,7 +1298,7 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestOriginEnumerator) {
   EXPECT_TRUE(diff.empty());
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestRevokeUsageCache) {
+TEST_F(ObfuscatedFileUtilTest, TestRevokeUsageCache) {
   scoped_ptr<FileSystemOperationContext> context(NewContext(NULL));
 
   int64 expected_quota = 0;
@@ -1311,19 +1307,19 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestRevokeUsageCache) {
     SCOPED_TRACE(testing::Message() << "Creating kMigrationTestPath " << i);
     const MigrationTestCaseRecord& test_case = kMigrationTestCases[i];
     FilePath path(test_case.path);
-    expected_quota += ObfuscatedFileSystemFileUtil::ComputeFilePathCost(path);
+    expected_quota += ObfuscatedFileUtil::ComputeFilePathCost(path);
     if (test_case.is_directory) {
       bool exclusive = true;
       bool recursive = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-          ofsfu()->CreateDirectory(context.get(), path, exclusive, recursive));
+          ofu()->CreateDirectory(context.get(), path, exclusive, recursive));
     } else {
       bool created = false;
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-          ofsfu()->EnsureFileExists(context.get(), path, &created));
+          ofu()->EnsureFileExists(context.get(), path, &created));
       ASSERT_TRUE(created);
       ASSERT_EQ(base::PLATFORM_FILE_OK,
-                ofsfu()->Truncate(context.get(), path,
+                ofu()->Truncate(context.get(), path,
                     test_case.data_file_size));
       expected_quota += test_case.data_file_size;
     }
@@ -1336,7 +1332,7 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestRevokeUsageCache) {
   EXPECT_EQ(expected_quota, usage());
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestInconsistency) {
+TEST_F(ObfuscatedFileUtilTest, TestInconsistency) {
   const FilePath kPath1 = FilePath().AppendASCII("hoge");
   const FilePath kPath2 = FilePath().AppendASCII("fuga");
 
@@ -1349,61 +1345,61 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestInconsistency) {
   // Create a non-empty file.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), kPath1, &created));
+            ofu()->EnsureFileExists(context.get(), kPath1, &created));
   EXPECT_TRUE(created);
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->Truncate(context.get(), kPath1, 10));
+            ofu()->Truncate(context.get(), kPath1, 10));
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->GetFileInfo(
+            ofu()->GetFileInfo(
                 context.get(), kPath1, &file_info, &data_path));
   EXPECT_EQ(10, file_info.size);
 
   // Destroy database to make inconsistency between database and filesystem.
-  ofsfu()->DestroyDirectoryDatabase(origin(), type());
+  ofu()->DestroyDirectoryDatabase(origin(), type());
 
   // Try to get file info of broken file.
   context.reset(NewContext(NULL));
-  EXPECT_FALSE(ofsfu()->PathExists(context.get(), kPath1));
+  EXPECT_FALSE(ofu()->PathExists(context.get(), kPath1));
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), kPath1, &created));
+            ofu()->EnsureFileExists(context.get(), kPath1, &created));
   EXPECT_TRUE(created);
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->GetFileInfo(
+            ofu()->GetFileInfo(
                 context.get(), kPath1, &file_info, &data_path));
   EXPECT_EQ(0, file_info.size);
 
   // Make another broken file to |kPath2|.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), kPath2, &created));
+            ofu()->EnsureFileExists(context.get(), kPath2, &created));
   EXPECT_TRUE(created);
 
   // Destroy again.
-  ofsfu()->DestroyDirectoryDatabase(origin(), type());
+  ofu()->DestroyDirectoryDatabase(origin(), type());
 
   // Repair broken |kPath1|.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND,
-            ofsfu()->Touch(context.get(), kPath1, base::Time::Now(),
+            ofu()->Touch(context.get(), kPath1, base::Time::Now(),
                            base::Time::Now()));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->EnsureFileExists(context.get(), kPath1, &created));
+            ofu()->EnsureFileExists(context.get(), kPath1, &created));
   EXPECT_TRUE(created);
 
   // Copy from sound |kPath1| to broken |kPath2|.
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->CopyOrMoveFile(context.get(), kPath1, kPath2,
+            ofu()->CopyOrMoveFile(context.get(), kPath1, kPath2,
                                     true /* copy */));
 
-  ofsfu()->DestroyDirectoryDatabase(origin(), type());
+  ofu()->DestroyDirectoryDatabase(origin(), type());
   context.reset(NewContext(NULL));
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->CreateOrOpen(
+            ofu()->CreateOrOpen(
                 context.get(), kPath1,
                 base::PLATFORM_FILE_READ | base::PLATFORM_FILE_CREATE,
                 &file, &created));
@@ -1413,7 +1409,7 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestInconsistency) {
   EXPECT_TRUE(base::ClosePlatformFile(file));
 }
 
-TEST_F(ObfuscatedFileSystemFileUtilTest, TestIncompleteDirectoryReading) {
+TEST_F(ObfuscatedFileUtilTest, TestIncompleteDirectoryReading) {
   const FilePath kPath[] = {
     FilePath().AppendASCII("foo"),
     FilePath().AppendASCII("bar"),
@@ -1425,25 +1421,25 @@ TEST_F(ObfuscatedFileSystemFileUtilTest, TestIncompleteDirectoryReading) {
     bool created = false;
     context.reset(NewContext(NULL));
     EXPECT_EQ(base::PLATFORM_FILE_OK,
-              ofsfu()->EnsureFileExists(context.get(), kPath[i], &created));
+              ofu()->EnsureFileExists(context.get(), kPath[i], &created));
     EXPECT_TRUE(created);
   }
 
   context.reset(NewContext(NULL));
   std::vector<base::FileUtilProxy::Entry> entries;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->ReadDirectory(context.get(), FilePath(), &entries));
+            ofu()->ReadDirectory(context.get(), FilePath(), &entries));
   EXPECT_EQ(3u, entries.size());
 
   context.reset(NewContext(NULL));
   FilePath local_path;
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->GetLocalFilePath(context.get(), kPath[0], &local_path));
+            ofu()->GetLocalFilePath(context.get(), kPath[0], &local_path));
   EXPECT_TRUE(file_util::Delete(local_path, false));
 
   context.reset(NewContext(NULL));
   entries.clear();
   EXPECT_EQ(base::PLATFORM_FILE_OK,
-            ofsfu()->ReadDirectory(context.get(), FilePath(), &entries));
+            ofu()->ReadDirectory(context.get(), FilePath(), &entries));
   EXPECT_EQ(ARRAYSIZE_UNSAFE(kPath) - 1, entries.size());
 }
diff --git a/webkit/fileapi/quota_file_util.cc b/webkit/fileapi/quota_file_util.cc
index 1cdf0d2..6ccb578 100644
--- a/webkit/fileapi/quota_file_util.cc
+++ b/webkit/fileapi/quota_file_util.cc
@@ -10,6 +10,7 @@
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_quota_util.h"
+#include "webkit/fileapi/native_file_util.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaManagerProxy;
@@ -68,7 +69,7 @@ void NotifyUpdate(FileSystemOperationContext* operation_context,
 }  // namespace (anonymous)
 
 QuotaFileUtil::QuotaFileUtil(FileSystemFileUtil* underlying_file_util)
-    : underlying_file_util_(underlying_file_util) {
+    : FileSystemFileUtil(underlying_file_util) {
 }
 
 QuotaFileUtil::~QuotaFileUtil() {
@@ -76,7 +77,35 @@ QuotaFileUtil::~QuotaFileUtil() {
 
 // static
 QuotaFileUtil* QuotaFileUtil::CreateDefault() {
-  return new QuotaFileUtil(new FileSystemFileUtil());
+  return new QuotaFileUtil(new NativeFileUtil());
+}
+
+base::PlatformFileError QuotaFileUtil::Truncate(
+    FileSystemOperationContext* fs_context,
+    const FilePath& path,
+    int64 length) {
+  int64 allowed_bytes_growth = fs_context->allowed_bytes_growth();
+
+  int64 growth = 0;
+  base::PlatformFileInfo file_info;
+  if (!file_util::GetFileInfo(path, &file_info))
+    return base::PLATFORM_FILE_ERROR_FAILED;
+
+  growth = length - file_info.size;
+  if (allowed_bytes_growth != kNoLimit &&
+      growth > 0 && growth > allowed_bytes_growth)
+    return base::PLATFORM_FILE_ERROR_NO_SPACE;
+
+  base::PlatformFileError error = underlying_file_util()->Truncate(
+      fs_context, path, length);
+
+  if (error == base::PLATFORM_FILE_OK)
+    NotifyUpdate(fs_context,
+                 fs_context->src_origin_url(),
+                 fs_context->src_type(),
+                 growth);
+
+  return error;
 }
 
 base::PlatformFileError QuotaFileUtil::CopyOrMoveFile(
@@ -102,7 +131,7 @@ base::PlatformFileError QuotaFileUtil::CopyOrMoveFile(
     growth = -dest_file_info.size;
   }
 
-  base::PlatformFileError error = underlying_file_util_->CopyOrMoveFile(
+  base::PlatformFileError error = underlying_file_util()->CopyOrMoveFile(
       fs_context, src_file_path, dest_file_path, copy);
 
   if (error == base::PLATFORM_FILE_OK) {
@@ -128,7 +157,7 @@ base::PlatformFileError QuotaFileUtil::DeleteFile(
     file_info.size = 0;
   growth = -file_info.size;
 
-  base::PlatformFileError error = underlying_file_util_->DeleteFile(
+  base::PlatformFileError error = underlying_file_util()->DeleteFile(
       fs_context, file_path);
 
   if (error == base::PLATFORM_FILE_OK)
@@ -140,32 +169,4 @@ base::PlatformFileError QuotaFileUtil::DeleteFile(
   return error;
 }
 
-base::PlatformFileError QuotaFileUtil::Truncate(
-    FileSystemOperationContext* fs_context,
-    const FilePath& path,
-    int64 length) {
-  int64 allowed_bytes_growth = fs_context->allowed_bytes_growth();
-
-  int64 growth = 0;
-  base::PlatformFileInfo file_info;
-  if (!file_util::GetFileInfo(path, &file_info))
-    return base::PLATFORM_FILE_ERROR_FAILED;
-
-  growth = length - file_info.size;
-  if (allowed_bytes_growth != kNoLimit &&
-      growth > 0 && growth > allowed_bytes_growth)
-    return base::PLATFORM_FILE_ERROR_NO_SPACE;
-
-  base::PlatformFileError error = underlying_file_util_->Truncate(
-      fs_context, path, length);
-
-  if (error == base::PLATFORM_FILE_OK)
-    NotifyUpdate(fs_context,
-                 fs_context->src_origin_url(),
-                 fs_context->src_type(),
-                 growth);
-
-  return error;
-}
-
 }  // namespace fileapi
diff --git a/webkit/fileapi/quota_file_util.h b/webkit/fileapi/quota_file_util.h
index 991497b..25be5f3 100644
--- a/webkit/fileapi/quota_file_util.h
+++ b/webkit/fileapi/quota_file_util.h
@@ -25,28 +25,24 @@ class QuotaFileUtil : public FileSystemFileUtil {
   explicit QuotaFileUtil(FileSystemFileUtil* underlying_file_util);
   virtual ~QuotaFileUtil();
 
-  // Creates a QuotaFileUtil instance with an underlying FileSystemFileUtil
+  // Creates a QuotaFileUtil instance with an underlying NativeFileUtil
   // instance.
   static QuotaFileUtil* CreateDefault();
 
+  virtual base::PlatformFileError Truncate(
+      FileSystemOperationContext* fs_context,
+      const FilePath& path,
+      int64 length) OVERRIDE;
   virtual base::PlatformFileError CopyOrMoveFile(
       FileSystemOperationContext* fs_context,
       const FilePath& src_file_path,
       const FilePath& dest_file_path,
       bool copy) OVERRIDE;
-
   virtual base::PlatformFileError DeleteFile(
       FileSystemOperationContext* fs_context,
       const FilePath& file_path) OVERRIDE;
 
-  virtual base::PlatformFileError Truncate(
-      FileSystemOperationContext* fs_context,
-      const FilePath& path,
-      int64 length) OVERRIDE;
-
  private:
-  scoped_ptr<FileSystemFileUtil> underlying_file_util_;
-
   DISALLOW_COPY_AND_ASSIGN(QuotaFileUtil);
 };
 
diff --git a/webkit/fileapi/quota_file_util_unittest.cc b/webkit/fileapi/quota_file_util_unittest.cc
index d8766e7..9b53e01 100644
--- a/webkit/fileapi/quota_file_util_unittest.cc
+++ b/webkit/fileapi/quota_file_util_unittest.cc
@@ -11,7 +11,6 @@
 #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_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_test_helper.h"
diff --git a/webkit/fileapi/sandbox_mount_point_provider.cc b/webkit/fileapi/sandbox_mount_point_provider.cc
index ebcdc37..8feb2ff 100644
--- a/webkit/fileapi/sandbox_mount_point_provider.cc
+++ b/webkit/fileapi/sandbox_mount_point_provider.cc
@@ -20,8 +20,7 @@
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_usage_cache.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/local_file_system_file_util.h"
-#include "webkit/fileapi/obfuscated_file_system_file_util.h"
+#include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/quota_manager.h"
@@ -96,7 +95,7 @@ class ObfuscatedOriginEnumerator
     : public fileapi::SandboxMountPointProvider::OriginEnumerator {
  public:
   explicit ObfuscatedOriginEnumerator(
-      fileapi::ObfuscatedFileSystemFileUtil* file_util) {
+      fileapi::ObfuscatedFileUtil* file_util) {
     enum_.reset(file_util->CreateOriginEnumerator());
   }
   virtual ~ObfuscatedOriginEnumerator() {}
@@ -110,8 +109,7 @@ class ObfuscatedOriginEnumerator
   }
 
  private:
-  scoped_ptr<fileapi::ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator>
-      enum_;
+  scoped_ptr<fileapi::ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
 class OldSandboxOriginEnumerator
@@ -172,7 +170,7 @@ FilePath OldGetBaseDirectoryForOriginAndType(
 }
 
 bool MigrateOneOldFileSystem(
-    fileapi::ObfuscatedFileSystemFileUtil* file_util,
+    fileapi::ObfuscatedFileUtil* file_util,
     const FilePath& old_base_path, const GURL& origin,
     fileapi::FileSystemType type) {
   FilePath base_path = OldGetBaseDirectoryForOriginAndType(
@@ -201,7 +199,7 @@ bool MigrateOneOldFileSystem(
 }
 
 void MigrateAllOldFileSystems(
-    fileapi::ObfuscatedFileSystemFileUtil* file_util,
+    fileapi::ObfuscatedFileUtil* file_util,
     const FilePath& old_base_path) {
   scoped_ptr<OldSandboxOriginEnumerator> old_origins(
       new OldSandboxOriginEnumerator(old_base_path));
@@ -250,7 +248,7 @@ void MigrateAllOldFileSystems(
 // to look up the filesystem's root, so we can take care of most of them by
 // putting a check there.
 void MigrateIfNeeded(
-    fileapi::ObfuscatedFileSystemFileUtil* file_util,
+    fileapi::ObfuscatedFileUtil* file_util,
     const FilePath& old_base_path) {
   if (file_util::DirectoryExists(old_base_path))
     MigrateAllOldFileSystems(file_util, old_base_path);
@@ -279,7 +277,7 @@ SandboxMountPointProvider::SandboxMountPointProvider(
       file_message_loop_(file_message_loop),
       profile_path_(profile_path),
       sandbox_file_util_(
-          new ObfuscatedFileSystemFileUtil(
+          new ObfuscatedFileUtil(
               profile_path.Append(kNewFileSystemDirectory),
               QuotaFileUtil::CreateDefault())) {
 }
@@ -306,7 +304,7 @@ class SandboxMountPointProvider::GetFileSystemRootPathTask
       scoped_refptr<base::MessageLoopProxy> file_message_loop,
       const GURL& origin_url,
       FileSystemType type,
-      ObfuscatedFileSystemFileUtil* file_util,
+      ObfuscatedFileUtil* file_util,
       const FilePath& old_base_path,
       FileSystemPathManager::GetRootPathCallback* callback)
       : file_message_loop_(file_message_loop),
@@ -360,7 +358,7 @@ class SandboxMountPointProvider::GetFileSystemRootPathTask
   scoped_refptr<base::MessageLoopProxy> origin_message_loop_proxy_;
   GURL origin_url_;
   FileSystemType type_;
-  scoped_refptr<ObfuscatedFileSystemFileUtil> file_util_;
+  scoped_refptr<ObfuscatedFileUtil> file_util_;
   FilePath old_base_path_;
   scoped_ptr<FileSystemPathManager::GetRootPathCallback> callback_;
 };
@@ -550,7 +548,7 @@ int64 SandboxMountPointProvider::GetOriginUsageOnFileThread(
     base::PlatformFileInfo file_info;
     FilePath platform_file_path;
     usage += enumerator->Size();
-    usage += ObfuscatedFileSystemFileUtil::ComputeFilePathCost(file_path_each);
+    usage += ObfuscatedFileUtil::ComputeFilePathCost(file_path_each);
   }
   // This clears the dirty flag too.
   FileSystemUsageCache::UpdateUsage(usage_file_path, usage);
@@ -616,7 +614,7 @@ void SandboxMountPointProvider::InvalidateUsageCache(
   FileSystemUsageCache::IncrementDirty(usage_file_path);
 }
 
-FileSystemFileUtil* SandboxMountPointProvider::GetFileSystemFileUtil() {
+FileSystemFileUtil* SandboxMountPointProvider::GetFileUtil() {
   return sandbox_file_util_.get();
 }
 
diff --git a/webkit/fileapi/sandbox_mount_point_provider.h b/webkit/fileapi/sandbox_mount_point_provider.h
index 8480581..b6cab5b 100644
--- a/webkit/fileapi/sandbox_mount_point_provider.h
+++ b/webkit/fileapi/sandbox_mount_point_provider.h
@@ -25,7 +25,7 @@ class QuotaManagerProxy;
 
 namespace fileapi {
 
-class ObfuscatedFileSystemFileUtil;
+class ObfuscatedFileUtil;
 
 // An interface to construct or crack sandboxed filesystem paths.
 // Currently each sandboxed filesystem path looks like (soon will be changed):
@@ -108,7 +108,7 @@ class SandboxMountPointProvider
       FileSystemType type,
       bool create) const;
 
-  virtual FileSystemFileUtil* GetFileSystemFileUtil();
+  virtual FileSystemFileUtil* GetFileUtil();
 
   // Deletes the data on the origin and reports the amount of deleted data
   // to the quota manager via |proxy|.
@@ -171,7 +171,7 @@ class SandboxMountPointProvider
 
   const FilePath profile_path_;
 
-  scoped_refptr<ObfuscatedFileSystemFileUtil> sandbox_file_util_;
+  scoped_refptr<ObfuscatedFileUtil> sandbox_file_util_;
 
   // Acccessed only on the file thread.
   std::set<GURL> visited_origins_;
diff --git a/webkit/fileapi/sandbox_mount_point_provider_unittest.cc b/webkit/fileapi/sandbox_mount_point_provider_unittest.cc
index 53d94a8..6b17ea2 100644
--- a/webkit/fileapi/sandbox_mount_point_provider_unittest.cc
+++ b/webkit/fileapi/sandbox_mount_point_provider_unittest.cc
@@ -164,7 +164,7 @@ class SandboxMountPointProviderMigrationTest : public testing::Test {
   }
 
   FileSystemFileUtil* file_util() {
-    return sandbox_provider()->GetFileSystemFileUtil();
+    return sandbox_provider()->GetFileUtil();
   }
 
   void OnGetRootPath(bool success, const FilePath& unused,
diff --git a/webkit/fileapi/webkit_fileapi.gypi b/webkit/fileapi/webkit_fileapi.gypi
index e8708c1..2f81151 100644
--- a/webkit/fileapi/webkit_fileapi.gypi
+++ b/webkit/fileapi/webkit_fileapi.gypi
@@ -50,10 +50,12 @@
         'file_system_util.h',
         'file_writer_delegate.cc',
         'file_writer_delegate.h',
-        'local_file_system_file_util.cc',
-        'local_file_system_file_util.h',
-        'obfuscated_file_system_file_util.cc',
-        'obfuscated_file_system_file_util.h',
+        'local_file_util.cc',
+        'local_file_util.h',
+        'native_file_util.cc',
+        'native_file_util.h',
+        'obfuscated_file_util.cc',
+        'obfuscated_file_util.h',
         'quota_file_util.cc',
         'quota_file_util.h',
         'sandbox_mount_point_provider.cc',
diff --git a/webkit/tools/test_shell/simple_file_system.cc b/webkit/tools/test_shell/simple_file_system.cc
index 6b30563..c20c0e9 100644
--- a/webkit/tools/test_shell/simple_file_system.cc
+++ b/webkit/tools/test_shell/simple_file_system.cc
@@ -21,7 +21,6 @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebVector.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
@@ -44,7 +43,6 @@ using WebKit::WebVector;
 
 using fileapi::FileSystemCallbackDispatcher;
 using fileapi::FileSystemContext;
-using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
 
 namespace {
diff --git a/webkit/tools/test_shell/simple_file_writer.cc b/webkit/tools/test_shell/simple_file_writer.cc
index fee2c55..8c07ccd 100644
--- a/webkit/tools/test_shell/simple_file_writer.cc
+++ b/webkit/tools/test_shell/simple_file_writer.cc
@@ -9,14 +9,12 @@
 #include "net/url_request/url_request_context.h"
 #include "webkit/fileapi/file_system_callback_dispatcher.h"
 #include "webkit/fileapi/file_system_context.h"
-#include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/tools/test_shell/simple_resource_loader_bridge.h"
 
 using fileapi::FileSystemCallbackDispatcher;
 using fileapi::FileSystemContext;
-using fileapi::FileSystemFileUtil;
 using fileapi::FileSystemOperation;
 using fileapi::WebFileWriterBase;
 using WebKit::WebFileWriterClient;
diff --git a/webkit/tools/test_shell/test_shell.gypi b/webkit/tools/test_shell/test_shell.gypi
index 2d457db..256376d 100644
--- a/webkit/tools/test_shell/test_shell.gypi
+++ b/webkit/tools/test_shell/test_shell.gypi
@@ -402,8 +402,8 @@
         '../../fileapi/file_system_quota_unittest.cc',
         '../../fileapi/file_system_usage_cache_unittest.cc',
         '../../fileapi/file_system_util_unittest.cc',
-        '../../fileapi/local_file_system_file_util_unittest.cc',
-        '../../fileapi/obfuscated_file_system_file_util_unittest.cc',
+        '../../fileapi/local_file_util_unittest.cc',
+        '../../fileapi/obfuscated_file_util_unittest.cc',
         '../../fileapi/quota_file_util_unittest.cc',
         '../../fileapi/sandbox_mount_point_provider_unittest.cc',
         '../../fileapi/file_system_test_helper.cc',