Cleanup: Remove FileSystemFileUtil::{Directory,Path}Exists

webkit/fileapi/file_util_helper.cc

 // Copyright (c) 2012 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/file_util_helper.h"
 
 #include <stack>
 
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
@@ skipping 87 matching lines @@
       src_root_url_.origin() == dest_root_url_.origin() &&
       src_root_url_.type() == dest_root_url_.type();
 }
 
 CrossFileUtilHelper::~CrossFileUtilHelper() {}
 
 base::PlatformFileError CrossFileUtilHelper::DoWork() {
   base::PlatformFileError error = PerformErrorCheckAndPreparation();
   if (error != base::PLATFORM_FILE_OK)
     return error;
-  if (src_util_->DirectoryExists(context_, src_root_url_))
+  if (FileUtilHelper::DirectoryExists(context_, src_util_, src_root_url_))
     return CopyOrMoveDirectory(src_root_url_, dest_root_url_);
   return CopyOrMoveFile(src_root_url_, dest_root_url_);
 }
 
 PlatformFileError CrossFileUtilHelper::PerformErrorCheckAndPreparation() {
   // Exits earlier if the source path does not exist.
-  if (!src_util_->PathExists(context_, src_root_url_))
+  if (!FileUtilHelper::PathExists(context_, src_util_, src_root_url_))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   // The parent of the |dest_root_url_| does not exist.
   if (!ParentExists(dest_root_url_, dest_util_))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   // It is an error to try to copy/move an entry into its child.
   if (same_file_system_ && src_root_url_.path().IsParent(dest_root_url_.path()))
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
 
   // Now it is ok to return if the |dest_root_url_| does not exist.
-  if (!dest_util_->PathExists(context_, dest_root_url_))
+  if (!FileUtilHelper::PathExists(context_, dest_util_, dest_root_url_))
     return base::PLATFORM_FILE_OK;
 
   // |src_root_url_| exists and is a directory.
   // |dest_root_url_| exists and is a file.
-  bool src_is_directory = src_util_->DirectoryExists(context_, src_root_url_);
+  bool src_is_directory =
+      FileUtilHelper::DirectoryExists(context_, src_util_, src_root_url_);
   bool dest_is_directory =
-      dest_util_->DirectoryExists(context_, dest_root_url_);
+      FileUtilHelper::DirectoryExists(context_, dest_util_, dest_root_url_);
 
   // Either one of |src_root_url_| or |dest_root_url_| is directory,
   // while the other is not.
   if (src_is_directory != dest_is_directory)
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
 
   // It is an error to copy/move an entry into the same path.
   if (same_file_system_ &&
       src_root_url_.path() == dest_root_url_.path())
     return base::PLATFORM_FILE_ERROR_EXISTS;
@@ skipping 13 matching lines @@
   return base::PLATFORM_FILE_OK;
 }
 
 bool CrossFileUtilHelper::ParentExists(
     const FileSystemURL& url, FileSystemFileUtil* file_util) {
   // If path is in the root, path.DirName() will be ".",
   // since we use paths with no leading '/'.
   FilePath parent = url.path().DirName();
   if (parent == FilePath(FILE_PATH_LITERAL(".")))
     return true;
-  return file_util->DirectoryExists(context_, url.WithPath(parent));
+  return FileUtilHelper::DirectoryExists(context_, file_util,
+                                         url.WithPath(parent));
 }
 
 PlatformFileError CrossFileUtilHelper::CopyOrMoveDirectory(
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url) {
   // At this point we must have gone through
   // PerformErrorCheckAndPreparationForMoveAndCopy so this must be true.
   DCHECK(!same_file_system_ ||
          !src_url.path().IsParent(dest_url.path()));
 
@@ skipping 99 matching lines @@
       context_, platform_file_path, dest_url);
 
   if (operation_ == OPERATION_COPY || error != base::PLATFORM_FILE_OK)
     return error;
   return src_util_->DeleteFile(context_, src_url);
 }
 
 }  // anonymous namespace
 
 // static
+bool FileUtilHelper::PathExists(FileSystemOperationContext* context,
+                                FileSystemFileUtil* file_util,
+                                const FileSystemURL& url) {
+  base::PlatformFileInfo file_info;
+  FilePath platform_path;
+  PlatformFileError error = file_util->GetFileInfo(
+      context, url, &file_info, &platform_path);
+  return error == base::PLATFORM_FILE_OK;
+}
+
+// static
+bool FileUtilHelper::DirectoryExists(FileSystemOperationContext* context,
+                                     FileSystemFileUtil* file_util,
+                                     const FileSystemURL& url) {
+  if (url.path().empty())
+    return true;
+
+  base::PlatformFileInfo file_info;
+  FilePath platform_path;
+  PlatformFileError error = file_util->GetFileInfo(
+      context, url, &file_info, &platform_path);
+  return error == base::PLATFORM_FILE_OK && file_info.is_directory;
+}
+
+// static
 base::PlatformFileError FileUtilHelper::Copy(
     FileSystemOperationContext* context,
     FileSystemFileUtil* src_file_util,
     FileSystemFileUtil* dest_file_util,
     const FileSystemURL& src_root_url,
     const FileSystemURL& dest_root_url) {
   return CrossFileUtilHelper(context, src_file_util, dest_file_util,
                              src_root_url, dest_root_url,
                              CrossFileUtilHelper::OPERATION_COPY).DoWork();
 }
 
 // static
 base::PlatformFileError FileUtilHelper::Move(
     FileSystemOperationContext* context,
     FileSystemFileUtil* src_file_util,
     FileSystemFileUtil* dest_file_util,
     const FileSystemURL& src_root_url,
     const FileSystemURL& dest_root_url) {
   return CrossFileUtilHelper(context, src_file_util, dest_file_util,
                              src_root_url, dest_root_url,
                              CrossFileUtilHelper::OPERATION_MOVE).DoWork();
 }
 
 // static
 base::PlatformFileError FileUtilHelper::Delete(
     FileSystemOperationContext* context,
     FileSystemFileUtil* file_util,
     const FileSystemURL& url,
     bool recursive) {
-  if (file_util->DirectoryExists(context, url)) {
+  if (DirectoryExists(context, file_util, url)) {
     if (!recursive)
       return file_util->DeleteSingleDirectory(context, url);
     else
       return DeleteDirectoryRecursive(context, file_util, url);
   } else {
     return file_util->DeleteFile(context, url);
   }
 }
 
 // static
 base::PlatformFileError FileUtilHelper::ReadDirectory(
     FileSystemOperationContext* context,
     FileSystemFileUtil* file_util,
     const FileSystemURL& url,
     std::vector<base::FileUtilProxy::Entry>* entries) {
   DCHECK(entries);
 
   // TODO(kkanetkar): Implement directory read in multiple chunks.
-  if (!file_util->DirectoryExists(context, url))
+  if (!DirectoryExists(context, file_util, url))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> file_enum(
       file_util->CreateFileEnumerator(context, url, false /* recursive */));
 
   FilePath current;
   while (!(current = file_enum->Next()).empty()) {
     base::FileUtilProxy::Entry entry;
     entry.is_directory = file_enum->IsDirectory();
     entry.name = current.BaseName().value();
@@ skipping 31 matching lines @@
         context, url.WithPath(directories.top()));
     if (error != base::PLATFORM_FILE_ERROR_NOT_FOUND &&
         error != base::PLATFORM_FILE_OK)
       return error;
     directories.pop();
   }
   return file_util->DeleteSingleDirectory(context, url);
 }
 
 }  // namespace fileapi