Move PathIsWritable, DirectoryExists, ContentsEqual, and TextContentsEqual to the base namespace.

webkit/browser/fileapi/obfuscated_file_util.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/browser/fileapi/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
@@ skipping 226 matching lines @@
     if (current_.path.empty())
       return false;
     base::FilePath::StringType type_string =
         ObfuscatedFileUtil::GetDirectoryNameForType(type);
     if (type_string.empty()) {
       NOTREACHED();
       return false;
     }
     base::FilePath path =
         base_file_path_.Append(current_.path).Append(type_string);
-    return file_util::DirectoryExists(path);
+    return base::DirectoryExists(path);
   }
 
  private:
   std::vector<OriginRecord> origins_;
   OriginRecord current_;
   base::FilePath base_file_path_;
 };
 
 ObfuscatedFileUtil::ObfuscatedFileUtil(
     quota::SpecialStoragePolicy* special_storage_policy,
@@ skipping 609 matching lines @@
   base::FilePath::StringType type_string = GetDirectoryNameForType(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
 
     if (error_code)
       *error_code = base::PLATFORM_FILE_ERROR_INVALID_URL;
     return base::FilePath();
   }
   base::FilePath path = origin_dir.Append(type_string);
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
-  if (!file_util::DirectoryExists(path) &&
+  if (!base::DirectoryExists(path) &&
       (!create || !file_util::CreateDirectory(path))) {
     error = create ?
           base::PLATFORM_FILE_ERROR_FAILED :
           base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
 
   if (error_code)
     *error_code = error;
   return path;
 }
@@ skipping 27 matching lines @@
   std::vector<FileSystemType> other_types;
   if (type != kFileSystemTypeTemporary)
     other_types.push_back(kFileSystemTypeTemporary);
   if (type != kFileSystemTypePersistent)
     other_types.push_back(kFileSystemTypePersistent);
   if (type != kFileSystemTypeSyncable)
     other_types.push_back(kFileSystemTypeSyncable);
   DCHECK(type != kFileSystemTypeSyncableForInternalSync);
 
   for (size_t i = 0; i < other_types.size(); ++i) {
-    if (file_util::DirectoryExists(
+    if (base::DirectoryExists(
             origin_path.Append(GetDirectoryNameForType(other_types[i])))) {
       // Other type's directory exists; just return true here.
       return true;
     }
   }
 
   // No other directories seem exist. Try deleting the entire origin directory.
   InitOriginDatabase(false);
   if (origin_database_) {
     origin_database_->RemovePathForOrigin(
@@ skipping 52 matching lines @@
 }
 
 // static
 int64 ObfuscatedFileUtil::ComputeFilePathCost(const base::FilePath& path) {
   return UsageForPath(VirtualPath::BaseName(path).value().size());
 }
 
 void ObfuscatedFileUtil::MaybePrepopulateDatabase() {
   base::FilePath isolated_origin_dir = file_system_directory_.Append(
       SandboxIsolatedOriginDatabase::kOriginDirectory);
-  if (!file_util::DirectoryExists(isolated_origin_dir))
+  if (!base::DirectoryExists(isolated_origin_dir))
     return;
 
   const FileSystemType kPrepopulateTypes[] = {
     kFileSystemTypePersistent, kFileSystemTypeTemporary
   };
 
   // Prepulate the directory database(s) if and only if this instance is
   // initialized for isolated storage dedicated for a single origin.
   for (size_t i = 0; i < arraysize(kPrepopulateTypes); ++i) {
     const FileSystemType type = kPrepopulateTypes[i];
     base::FilePath::StringType type_string = GetDirectoryNameForType(type);
     DCHECK(!type_string.empty());
     base::FilePath path = isolated_origin_dir.Append(type_string);
-    if (!file_util::DirectoryExists(path))
+    if (!base::DirectoryExists(path))
       continue;
     scoped_ptr<SandboxDirectoryDatabase> db(new SandboxDirectoryDatabase(path));
     if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) {
       directories_[GetFileSystemTypeString(type)] = db.release();
       MarkUsed();
       // Don't populate more than one database, as it may rather hurt
       // performance.
       break;
     }
   }
@@ skipping 208 matching lines @@
       *error_code = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     return base::FilePath();
   }
   if (!origin_database_->GetPathForOrigin(id, &directory_name)) {
     if (error_code)
       *error_code = base::PLATFORM_FILE_ERROR_FAILED;
     return base::FilePath();
   }
 
   base::FilePath path = file_system_directory_.Append(directory_name);
-  bool exists_in_fs = file_util::DirectoryExists(path);
+  bool exists_in_fs = base::DirectoryExists(path);
   if (!exists_in_db && exists_in_fs) {
     if (!base::Delete(path, true)) {
       if (error_code)
         *error_code = base::PLATFORM_FILE_ERROR_FAILED;
       return base::FilePath();
     }
     exists_in_fs = false;
   }
 
   if (!exists_in_fs) {
@@ skipping 39 matching lines @@
   STLDeleteContainerPairSecondPointers(
       directories_.begin(), directories_.end());
   directories_.clear();
   timer_.reset();
 }
 
 bool ObfuscatedFileUtil::InitOriginDatabase(bool create) {
   if (origin_database_)
     return true;
 
-  if (!create && !file_util::DirectoryExists(file_system_directory_))
+  if (!create && !base::DirectoryExists(file_system_directory_))
     return false;
   if (!file_util::CreateDirectory(file_system_directory_)) {
     LOG(WARNING) << "Failed to create FileSystem directory: " <<
         file_system_directory_.value();
     return false;
   }
 
   if (!isolated_origin_.is_empty()) {
     origin_database_.reset(
         new SandboxIsolatedOriginDatabase(
@@ skipping 134 matching lines @@
   // special_storage_policy_->HasIsolatedStorage(origin) returns false
   // for the same origin.
   if (!isolated_origin_.is_empty()) {
     CHECK_EQ(isolated_origin_.spec(), origin.spec());
     return true;
   }
   return false;
 }
 
 }  // namespace fileapi