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

webkit/fileapi/sandbox_mount_point_provider.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/sandbox_mount_point_provider.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_callback_factory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.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_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/local_file_util.h"
+#include "webkit/fileapi/obfuscated_file_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/quota_manager.h"
 
 using quota::QuotaManagerProxy;
 
 namespace {
 
 static const FilePath::CharType kOldFileSystemUniqueNamePrefix[] =
@@ skipping 55 matching lines @@
   }
   if (unique->empty())
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   return base::PLATFORM_FILE_OK;
 }
 
 class ObfuscatedOriginEnumerator
     : public fileapi::SandboxMountPointProvider::OriginEnumerator {
  public:
   explicit ObfuscatedOriginEnumerator(
-      fileapi::ObfuscatedFileSystemFileUtil* file_util) {
+      fileapi::ObfuscatedFileUtil* file_util) {
     enum_.reset(file_util->CreateOriginEnumerator());
   }
   virtual ~ObfuscatedOriginEnumerator() {}
 
   virtual GURL Next() OVERRIDE {
     return enum_->Next();
   }
 
   virtual bool HasFileSystemType(fileapi::FileSystemType type) const OVERRIDE {
     return enum_->HasFileSystemType(type);
   }
 
  private:
-  scoped_ptr<fileapi::ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator>
-      enum_;
+  scoped_ptr<fileapi::ObfuscatedFileUtil::AbstractOriginEnumerator> enum_;
 };
 
 class OldSandboxOriginEnumerator
     : public fileapi::SandboxMountPointProvider::OriginEnumerator {
  public:
   explicit OldSandboxOriginEnumerator(const FilePath& base_path)
       : enumerator_(base_path, false /* recursive */,
                     file_util::FileEnumerator::DIRECTORIES) {}
   virtual ~OldSandboxOriginEnumerator() {}
 
@@ skipping 40 matching lines @@
   FilePath base_path = OldGetBaseDirectoryForOrigin(
       old_base_path, origin_url);
   if (base_path.empty()) {
     NOTREACHED();
     return FilePath();
   }
   return base_path.AppendASCII(type_string);
 }
 
 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(
       old_base_path, origin, type);
   if (base_path.empty())
     return false;
 
   FilePath root;
   base::PlatformFileError result = OldReadOriginDirectory(base_path, &root);
   if (base::PLATFORM_FILE_ERROR_NOT_FOUND == result)
     return true;  // There was nothing to migrate; call that a success.
 
   // If we found more than one filesystem [a problem we don't know how to
   // solve], the data is already not accessible through Chrome, so it won't do
   // any harm not to migrate it.  Just flag it as an error, so that we don't
   // delete it.
   if (base::PLATFORM_FILE_OK != result)
     return false;
 
   if (!file_util->MigrateFromOldSandbox(origin, type, root)) {
     LOG(WARNING) << "Failed to migrate filesystem for origin " << origin <<
         " and type " << type;
     return false;
   }
   return true;
 }
 
 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));
   GURL origin;
   int failures = 0;
   while (!(origin = old_origins->Next()).is_empty()) {
     int failures_this_origin = 0;
     if (old_origins->HasFileSystemType(fileapi::kFileSystemTypeTemporary) &&
         !MigrateOneOldFileSystem(
             file_util, old_base_path, origin,
@@ skipping 28 matching lines @@
   }
 }
 
 // A migration, whether successful or not, will try to move this directory out
 // of the way so that we never try to migrate it again.  We need to do this
 // check on all public entry points in this file, so that it's guaranteed to be
 // done before anyone looks up a filesystem.  Most entry points start by trying
 // 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);
 }
 
 }  // anonymous namespace
 
 namespace fileapi {
 
 const FilePath::CharType SandboxMountPointProvider::kOldFileSystemDirectory[] =
     FILE_PATH_LITERAL("FileSystem");
 
 const FilePath::CharType SandboxMountPointProvider::kNewFileSystemDirectory[] =
     FILE_PATH_LITERAL("File System");
 
 const FilePath::CharType
     SandboxMountPointProvider::kRenamedOldFileSystemDirectory[] =
         FILE_PATH_LITERAL("FS.old");
 
 SandboxMountPointProvider::SandboxMountPointProvider(
     FileSystemPathManager* path_manager,
     scoped_refptr<base::MessageLoopProxy> file_message_loop,
     const FilePath& profile_path)
     : FileSystemQuotaUtil(file_message_loop),
       path_manager_(path_manager),
       file_message_loop_(file_message_loop),
       profile_path_(profile_path),
       quota_file_util_(QuotaFileUtil::CreateDefault()),
       sandbox_file_util_(
-          new ObfuscatedFileSystemFileUtil(
+          new ObfuscatedFileUtil(
               profile_path.Append(kNewFileSystemDirectory),
               quota_file_util_)) {
 }
 
 SandboxMountPointProvider::~SandboxMountPointProvider() {
   if (!file_message_loop_->BelongsToCurrentThread())
     file_message_loop_->ReleaseSoon(FROM_HERE, sandbox_file_util_.release());
 }
 
 bool SandboxMountPointProvider::IsAccessAllowed(const GURL& origin_url,
                                                 FileSystemType type,
                                                 const FilePath& unused) {
   if (type != kFileSystemTypeTemporary && type != kFileSystemTypePersistent)
     return false;
   // We essentially depend on quota to do our access controls.
   return path_manager_->IsAllowedScheme(origin_url);
 }
 
 class SandboxMountPointProvider::GetFileSystemRootPathTask
     : public base::RefCountedThreadSafe<
         SandboxMountPointProvider::GetFileSystemRootPathTask> {
  public:
   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),
         origin_message_loop_proxy_(
             base::MessageLoopProxy::CreateForCurrentThread()),
         origin_url_(origin_url),
         type_(type),
         file_util_(file_util),
         old_base_path_(old_base_path),
         callback_(callback) {
@@ skipping 33 matching lines @@
     DCHECK(!type_string.empty());
     std::string name = origin_identifier + ":" + type_string;
     callback_->Run(!root_path.empty(), root_path, name);
     callback_.reset();
   }
 
   scoped_refptr<base::MessageLoopProxy> file_message_loop_;
   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_;
 };
 
 FilePath SandboxMountPointProvider::old_base_path() const {
   return profile_path_.Append(kOldFileSystemDirectory);
 }
 
 FilePath SandboxMountPointProvider::new_base_path() const {
   return profile_path_.Append(kNewFileSystemDirectory);
@@ skipping 158 matching lines @@
     // initialized and running.  Read the cache file to get the usage.
     return FileSystemUsageCache::GetUsage(usage_file_path);
   }
   // The usage cache has not been initialized or the cache is dirty.
   // Get the directory size now and update the cache.
   FileSystemUsageCache::Delete(usage_file_path);
 
   FileSystemOperationContext context(NULL, sandbox_file_util_);
   context.set_src_origin_url(origin_url);
   context.set_src_type(type);
-  scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator(
+  scoped_ptr<FileApiFileUtil::AbstractFileEnumerator> enumerator(
       sandbox_file_util_->CreateFileEnumerator(&context, FilePath()));
 
   FilePath file_path_each;
   int64 usage = 0;
 
   // TODO(ericu): This could be made much more efficient if the
   // AbstractFileEnumerator also had an interface to tell you the size of the
   // file.  ObfuscatedFileSystemFileEnumerator has already looked up the data,
   // and it's a big waste to look it up again.  The other implementers could
   // easily add it on-demand, so as not to waste time when it's not needed.
@@ skipping 58 matching lines @@
 
 void SandboxMountPointProvider::EndUpdateOriginOnFileThread(
     const GURL& origin_url, fileapi::FileSystemType type) {
   DCHECK(type == fileapi::kFileSystemTypeTemporary ||
          type == fileapi::kFileSystemTypePersistent);
   FilePath usage_file_path = GetUsageCachePathForOriginAndType(
       origin_url, type);
   FileSystemUsageCache::DecrementDirty(usage_file_path);
 }
 
-FileSystemFileUtil* SandboxMountPointProvider::GetFileSystemFileUtil() {
+FileApiFileUtil* SandboxMountPointProvider::GetFileUtil() {
   return sandbox_file_util_.get();
 }
 
 FilePath SandboxMountPointProvider::GetUsageCachePathForOriginAndType(
     const GURL& origin_url, fileapi::FileSystemType type) const {
   FilePath base_path =
       GetBaseDirectoryForOriginAndType(origin_url, type, false);
   if (base_path.empty())
     return FilePath();
   return base_path.AppendASCII(FileSystemUsageCache::kUsageFileName);
@@ skipping 18 matching lines @@
 
   // Creates the root directory.
   root = origin_base_path.Append(OldCreateUniqueDirectoryName(origin_url));
   if (!file_util::CreateDirectory(root))
     return FilePath();
 
   return root;
 }
 
 }  // namespace fileapi