Change {Obfuscated|Local}FileSystemFileUtil non-Singleton to take an underlying *FileUtil.

webkit/fileapi/local_file_system_file_util.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "webkit/fileapi/local_file_system_file_util.h"
 
 #include "base/file_util_proxy.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
-#include "webkit/fileapi/quota_file_util.h"
 
 namespace fileapi {
 
-LocalFileSystemFileUtil* LocalFileSystemFileUtil::GetInstance() {
-  return Singleton<LocalFileSystemFileUtil>::get();
+LocalFileSystemFileUtil::LocalFileSystemFileUtil(
+    FileSystemFileUtil* underlying_file_util)
+    : underlying_file_util_(underlying_file_util) {
 }
 
 PlatformFileError LocalFileSystemFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FilePath& file_path, int file_flags,
     PlatformFile* file_handle, bool* created) {
   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 QuotaFileUtil::GetInstance()->CreateOrOpen(
+  return underlying_file_util_->CreateOrOpen(
       context, local_path, file_flags, file_handle, created);
 }
 
 PlatformFileError LocalFileSystemFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     bool* created) {
   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 QuotaFileUtil::GetInstance()->EnsureFileExists(
+  return underlying_file_util_->EnsureFileExists(
       context, local_path, created);
 }
 
 PlatformFileError LocalFileSystemFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     FilePath* local_path) {
   FilePath 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;
 }
 
 PlatformFileError LocalFileSystemFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     base::PlatformFileInfo* file_info,
     FilePath* platform_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 QuotaFileUtil::GetInstance()->GetFileInfo(
+  return underlying_file_util_->GetFileInfo(
       context, local_path, file_info, platform_file_path);
 }
 
 PlatformFileError LocalFileSystemFileUtil::ReadDirectory(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     std::vector<base::FileUtilProxy::Entry>* entries) {
   // TODO(kkanetkar): Implement directory read in multiple chunks.
   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 QuotaFileUtil::GetInstance()->ReadDirectory(
+  return underlying_file_util_->ReadDirectory(
       context, local_path, entries);
 }
 
 PlatformFileError LocalFileSystemFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     bool exclusive,
     bool recursive) {
   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 QuotaFileUtil::GetInstance()->CreateDirectory(
+  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 QuotaFileUtil::GetInstance()->CopyOrMoveFile(
+  return underlying_file_util_->CopyOrMoveFile(
       context, local_src_path, local_dest_path, copy);
 }
 
 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 QuotaFileUtil::GetInstance()->CopyOrMoveFile(
+  return underlying_file_util_->CopyOrMoveFile(
       context, src_file_path, local_dest_path, true);
 }
 
 PlatformFileError LocalFileSystemFileUtil::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 QuotaFileUtil::GetInstance()->DeleteFile(
+  return underlying_file_util_->DeleteFile(
       context, local_path);
 }
 
 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 QuotaFileUtil::GetInstance()->DeleteSingleDirectory(
+  return underlying_file_util_->DeleteSingleDirectory(
       context, local_path);
 }
 
 PlatformFileError LocalFileSystemFileUtil::Touch(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
   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 QuotaFileUtil::GetInstance()->Touch(
+  return underlying_file_util_->Touch(
       context, local_path, last_access_time, last_modified_time);
 }
 
 PlatformFileError LocalFileSystemFileUtil::Truncate(
     FileSystemOperationContext* context,
     const FilePath& file_path,
     int64 length) {
   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 QuotaFileUtil::GetInstance()->Truncate(
+  return underlying_file_util_->Truncate(
       context, local_path, length);
 }
 
 bool LocalFileSystemFileUtil::PathExists(
     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 false;
-  return QuotaFileUtil::GetInstance()->PathExists(
+  return underlying_file_util_->PathExists(
       context, local_path);
 }
 
 bool LocalFileSystemFileUtil::DirectoryExists(
     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 false;
-  return QuotaFileUtil::GetInstance()->DirectoryExists(
+  return underlying_file_util_->DirectoryExists(
       context, local_path);
 }
 
 bool LocalFileSystemFileUtil::IsDirectoryEmpty(
     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 true;
-  return QuotaFileUtil::GetInstance()->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::FILE_TYPE file_type)
@@ skipping 52 matching lines @@
     const FilePath& virtual_path) {
   FilePath root = context->file_system_context()->path_manager()->
       ValidateFileSystemRootAndGetPathOnFileThread(origin_url, type,
           virtual_path, false);
   if (root.empty())
     return FilePath();
   return root.Append(virtual_path);
 }
 
 }  // namespace fileapi