Move file_util::Delete 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 883 matching lines @@
   if (origin_type_path.empty())
     return true;
 
   if (error != base::PLATFORM_FILE_ERROR_NOT_FOUND) {
     // 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 */))
+    if (!base::Delete(origin_type_path, true /* recursive */))
       return false;
   }
 
   base::FilePath origin_path = VirtualPath::DirName(origin_type_path);
   DCHECK_EQ(origin_path.value(),
             GetDirectoryForOrigin(origin, false, NULL).value());
 
   // At this point we are sure we had successfully deleted the origin/type
   // directory (i.e. we're ready to just return true).
   // See if we have other directories in this origin directory.
@@ skipping 13 matching lines @@
       return true;
     }
   }
 
   // No other directories seem exist. Try deleting the entire origin directory.
   InitOriginDatabase(false);
   if (origin_database_) {
     origin_database_->RemovePathForOrigin(
         webkit_database::GetIdentifierFromOrigin(origin));
   }
-  if (!file_util::Delete(origin_path, true /* recursive */))
+  if (!base::Delete(origin_path, true /* recursive */))
     return false;
 
   return true;
 }
 
 // static
 base::FilePath::StringType ObfuscatedFileUtil::GetDirectoryNameForType(
     FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
@@ skipping 148 matching lines @@
 
   bool created = false;
   if (!src_file_path.empty()) {
     DCHECK(!file_flags);
     DCHECK(!handle);
     error = NativeFileUtil::CopyOrMoveFile(
         src_file_path, dest_local_path, true /* copy */);
     created = true;
   } else {
     if (file_util::PathExists(dest_local_path)) {
-      if (!file_util::Delete(dest_local_path, true /* recursive */)) {
+      if (!base::Delete(dest_local_path, true /* recursive */)) {
         NOTREACHED();
         return base::PLATFORM_FILE_ERROR_FAILED;
       }
       LOG(WARNING) << "A stray file detected";
       InvalidateUsageCache(context, dest_origin, dest_type);
     }
 
     if (handle) {
       error = NativeFileUtil::CreateOrOpen(
           dest_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 = NativeFileUtil::EnsureFileExists(dest_local_path, &created);
     }
   }
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   if (!created) {
     NOTREACHED();
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
-      file_util::Delete(dest_local_path, false /* recursive */);
+      base::Delete(dest_local_path, false /* recursive */);
     }
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
 
   // This removes the root, including the trailing slash, leaving a relative
   // path.
   dest_file_info->data_path = base::FilePath(
       dest_local_path.value().substr(root.value().length() + 1));
 
   FileId file_id;
   if (!db->AddFileInfo(*dest_file_info, &file_id)) {
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
     }
-    file_util::Delete(dest_local_path, false /* recursive */);
+    base::Delete(dest_local_path, false /* recursive */);
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   TouchDirectory(db, dest_file_info->parent_id);
 
   return base::PLATFORM_FILE_OK;
 }
 
 base::FilePath ObfuscatedFileUtil::DataPathToLocalPath(
     const GURL& origin, FileSystemType type, const base::FilePath& data_path) {
   PlatformFileError error = base::PLATFORM_FILE_OK;
@@ skipping 74 matching lines @@
   }
   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);
   if (!exists_in_db && exists_in_fs) {
-    if (!file_util::Delete(path, true)) {
+    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) {
     if (!create || !file_util::CreateDirectory(path)) {
       if (error_code)
@@ skipping 192 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