Move file_util::Delete to the base namespace

chrome/installer/setup/uninstall.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.
 //
 // This file defines the methods useful for uninstalling Chrome.
 
 #include "chrome/installer/setup/uninstall.h"
 
 #include <windows.h>
 
@@ skipping 252 matching lines @@
   base::FilePath setup_exe_base_name(installer::kSetupExe);
 
   while (true) {
     base::FilePath to_delete(file_enumerator.Next());
     if (to_delete.empty())
       break;
     if (!remove_setup && to_delete.BaseName() == setup_exe_base_name)
       continue;
 
     VLOG(1) << "Deleting installer path " << to_delete.value();
-    if (!file_util::Delete(to_delete, true)) {
+    if (!base::Delete(to_delete, true)) {
       LOG(ERROR) << "Failed to delete path: " << to_delete.value();
       success = false;
     }
   }
 
   return success;
 }
 
 }  // namespace
 
@@ skipping 111 matching lines @@
   DELETE_REQUIRES_REBOOT,
 };
 
 // Deletes the given directory if it is empty. Returns DELETE_SUCCEEDED if the
 // directory is deleted, DELETE_NOT_EMPTY if it is not empty, and DELETE_FAILED
 // otherwise.
 DeleteResult DeleteEmptyDir(const base::FilePath& path) {
   if (!file_util::IsDirectoryEmpty(path))
     return DELETE_NOT_EMPTY;
 
-  if (file_util::Delete(path, true))
+  if (base::Delete(path, true))
     return DELETE_SUCCEEDED;
 
   LOG(ERROR) << "Failed to delete folder: " << path.value();
   return DELETE_FAILED;
 }
 
 void GetLocalStateFolders(const Product& product,
                           std::vector<base::FilePath>* paths) {
   // Obtain the location of the user profile data.
   product.GetUserDataPaths(paths);
@@ skipping 26 matching lines @@
 DeleteResult DeleteLocalState(
     const std::vector<base::FilePath>& local_state_folders,
     bool schedule_on_failure) {
   if (local_state_folders.empty())
     return DELETE_SUCCEEDED;
 
   DeleteResult result = DELETE_SUCCEEDED;
   for (size_t i = 0; i < local_state_folders.size(); ++i) {
     const base::FilePath& user_local_state = local_state_folders[i];
     VLOG(1) << "Deleting user profile " << user_local_state.value();
-    if (!file_util::Delete(user_local_state, true)) {
+    if (!base::Delete(user_local_state, true)) {
       LOG(ERROR) << "Failed to delete user profile dir: "
                  << user_local_state.value();
       if (schedule_on_failure) {
         ScheduleDirectoryForDeletion(user_local_state.value().c_str());
         result = DELETE_REQUIRES_REBOOT;
       } else {
         result = DELETE_FAILED;
       }
     }
   }
@@ skipping 73 matching lines @@
     LOG(ERROR) << "DeleteAppHostFilesAndFolders: no installation destination "
                << "path.";
     return DELETE_FAILED;  // Nothing else we can do to uninstall, so we return.
   }
 
   DeleteInstallTempDir(target_path);
 
   DeleteResult result = DELETE_SUCCEEDED;
 
   base::FilePath app_host_exe(target_path.Append(installer::kChromeAppHostExe));
-  if (!file_util::Delete(app_host_exe, false)) {
+  if (!base::Delete(app_host_exe, false)) {
     result = DELETE_FAILED;
     LOG(ERROR) << "Failed to delete path: " << app_host_exe.value();
   }
 
   return result;
 }
 
 DeleteResult DeleteChromeFilesAndFolders(const InstallerState& installer_state,
                                          const base::FilePath& setup_exe) {
   const base::FilePath& target_path = installer_state.target_path();
@@ skipping 25 matching lines @@
     if (to_delete.BaseName().value() == installer::kChromeAppHostExe)
       continue;
     if (!installer_directory.empty() &&
         (to_delete == installer_directory ||
          installer_directory.IsParent(to_delete) ||
          to_delete.IsParent(installer_directory))) {
       continue;
     }
 
     VLOG(1) << "Deleting install path " << to_delete.value();
-    if (!file_util::Delete(to_delete, true)) {
+    if (!base::Delete(to_delete, true)) {
       LOG(ERROR) << "Failed to delete path (1st try): " << to_delete.value();
       if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
         // We don't try killing Chrome processes for Chrome Frame builds since
         // that is unlikely to help. Instead, schedule files for deletion and
         // return a value that will trigger a reboot prompt.
         base::FileEnumerator::FileInfo find_info = file_enumerator.GetInfo();
         if (find_info.IsDirectory())
           ScheduleDirectoryForDeletion(to_delete.value().c_str());
         else
           ScheduleFileSystemEntityForDeletion(to_delete.value().c_str());
         result = DELETE_REQUIRES_REBOOT;
       } else {
         // Try closing any running Chrome processes and deleting files once
         // again.
         CloseAllChromeProcesses();
-        if (!file_util::Delete(to_delete, true)) {
+        if (!base::Delete(to_delete, true)) {
           LOG(ERROR) << "Failed to delete path (2nd try): "
                      << to_delete.value();
           result = DELETE_FAILED;
           break;
         }
       }
     }
   }
 
   return result;
@@ skipping 725 matching lines @@
 
   if (!force_uninstall) {
     VLOG(1) << "Uninstallation complete. Launching post-uninstall operations.";
     browser_dist->DoPostUninstallOperations(product_state->version(),
         backup_state_file, distribution_data);
   }
 
   // Try and delete the preserved local state once the post-install
   // operations are complete.
   if (!backup_state_file.empty())
-    file_util::Delete(backup_state_file, false);
+    base::Delete(backup_state_file, false);
 
   return ret;
 }
 
 void CleanUpInstallationDirectoryAfterUninstall(
     const InstallationState& original_state,
     const InstallerState& installer_state,
     const CommandLine& cmd_line,
     installer::InstallStatus* uninstall_status) {
   if (*uninstall_status != installer::UNINSTALL_SUCCESSFUL &&
@@ skipping 61 matching lines @@
     // deletion unconditionally. If they are not empty, the session manager
     // will not delete them on reboot.
     ScheduleParentAndGrandparentForDeletion(target_path);
   } else if (DeleteApplicationProductAndVendorDirectories(target_path) ==
              installer::DELETE_FAILED) {
     *uninstall_status = installer::UNINSTALL_FAILED;
   }
 }
 
 }  // namespace installer