Delete the installation folder after deleting its contents.

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 300 matching lines @@
     FilePath grandparent_dir(parent_dir.DirName());
     ret = ScheduleFileSystemEntityForDeletion(grandparent_dir.value().c_str());
     if (!ret) {
       LOG(ERROR) << "Failed to schedule grandparent dir for deletion: "
                  << grandparent_dir.value();
     }
   }
   return ret;
 }
 
-// Deletes empty parent & empty grandparent dir of given path.
-bool DeleteEmptyParentDir(const FilePath& path) {
-  bool ret = true;
-  FilePath parent_dir = path.DirName();
-  if (!parent_dir.empty() && file_util::IsDirectoryEmpty(parent_dir)) {
-    if (!file_util::Delete(parent_dir, true)) {
-      ret = false;
-      LOG(ERROR) << "Failed to delete folder: " << parent_dir.value();
-    }
+// Deletes the given directory if it is empty. Returns true if the directory is
+// deleted. *error is set to true iff the attempt to delete the file fails.
+bool DeleteEmptyDir(const FilePath& path, bool* error) {

[gab, 2012/08/09 16:07:22]

I'm not a fan of the bool return and bool* error param.

Could you remove |error| and make the return an enum?

edit: My desire to remove |error| is even stronger as I see its value is not
even used in every scenario below.

Maybe add DELETE_INVALID or something to the DeleteValue enum?

[erikwright (departed), 2012/08/13 14:53:22]

Done.

+  *error = false;
 
-    parent_dir = parent_dir.DirName();
-    if (!parent_dir.empty() && file_util::IsDirectoryEmpty(parent_dir)) {
-      if (!file_util::Delete(parent_dir, true)) {
-        ret = false;
-        LOG(ERROR) << "Failed to delete folder: " << parent_dir.value();
-      }
-    }
-  }
-  return ret;
+  if (path.empty())
+    return false;
+
+  if (!file_util::IsDirectoryEmpty(path))

[gab, 2012/08/09 16:07:22]

Group this condition with path.empty() above since the result (return false) is
the same.

[erikwright (departed), 2012/08/13 14:53:22]

N/A.

+    return false;
+
+  if (file_util::Delete(path, true))
+    return true;
+
+  *error = true;
+  LOG(ERROR) << "Failed to delete folder: " << path.value();
+  return false;
 }
 
 void GetLocalStateFolders(const Product& product,
                           std::vector<FilePath>* paths) {
   // Obtain the location of the user profile data.
   product.GetUserDataPaths(paths);
   LOG_IF(ERROR, paths->empty())
       << "Could not retrieve user's profile directory.";
 }
 
@@ skipping 41 matching lines @@
         result = DELETE_REQUIRES_REBOOT;
       } else {
         result = DELETE_FAILED;
       }
     }
   }
 
   if (result == DELETE_REQUIRES_REBOOT) {
     ScheduleParentAndGrandparentForDeletion(local_state_folders[0]);
   } else {
-    DeleteEmptyParentDir(local_state_folders[0]);
+    bool error = false;
+    if (DeleteEmptyDir(local_state_folders[0].DirName(), &error))
+      DeleteEmptyDir(local_state_folders[0].DirName().DirName(), &error);
   }
 
   return result;
 }
 
 bool MoveSetupOutOfInstallFolder(const InstallerState& installer_state,
                                  const FilePath& setup_path,
                                  const Version& installed_version) {
   bool ret = false;
   FilePath setup_exe(installer_state.GetInstallerDirectory(installed_version)
@@ skipping 27 matching lines @@
 
   DeleteInstallTempDir(target_path);
 
   DeleteResult result = DELETE_SUCCEEDED;
 
   FilePath app_host_exe(target_path.Append(installer::kChromeAppHostExe));
   if (!file_util::Delete(app_host_exe, false)) {
     result = DELETE_FAILED;
     LOG(ERROR) << "Failed to delete path: " << app_host_exe.value();
   } else {
-    DeleteEmptyParentDir(target_path);
+    bool error = false;
+    if (DeleteEmptyDir(target_path, &error)) {
+      // Now check and delete if the parent directories are empty
+      // For example Google\Chrome or Chromium
+      if (DeleteEmptyDir(target_path.DirName(), &error))
+        DeleteEmptyDir(target_path.DirName().DirName(), &error);
+    }
+    if (error)
+      result = DELETE_FAILED;
   }
 
   return result;
 }
 
 DeleteResult DeleteChromeFilesAndFolders(const InstallerState& installer_state,
                                          const Version& installed_version) {
   const FilePath& target_path = installer_state.target_path();
   if (target_path.empty()) {
     LOG(ERROR) << "DeleteChromeFilesAndFolders: no installation destination "
@@ skipping 11 matching lines @@
       false,
       static_cast<FileEnumerator::FileType>(FileEnumerator::FILES |
                                             FileEnumerator::DIRECTORIES));
   while (true) {
     FilePath to_delete(file_enumerator.Next());
     if (to_delete.empty())
       break;
     if (to_delete.BaseName().value() == installer::kChromeAppHostExe)
       continue;
 
-    VLOG(1) << "Deleting install path " << target_path.value();
+    VLOG(1) << "Deleting install path " << to_delete.value();
     if (!file_util::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.
         FileEnumerator::FindInfo find_info;
         file_enumerator.GetFindInfo(&find_info);
         if (FileEnumerator::IsDirectory(find_info))
           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)) {
           LOG(ERROR) << "Failed to delete path (2nd try): "
                      << to_delete.value();
           result = DELETE_FAILED;
           break;
         }
       }
     }
   }
 
   if (result == DELETE_REQUIRES_REBOOT) {
+    // Delete the Application directory at reboot if empty.
+    ScheduleFileSystemEntityForDeletion(target_path.value().c_str());
+
     // If we need a reboot to continue, schedule the parent directories for
     // deletion unconditionally. If they are not empty, the session manager
     // will not delete them on reboot.
     ScheduleParentAndGrandparentForDeletion(target_path);
   } else {
-    // Now check and delete if the parent directories are empty
-    // For example Google\Chrome or Chromium
-    DeleteEmptyParentDir(target_path);
+    bool error = false;
+    if (DeleteEmptyDir(target_path, &error)) {
+      // Now check and delete if the parent directories are empty
+      // For example Google\Chrome or Chromium
+      if (DeleteEmptyDir(target_path.DirName(), &error))
+        DeleteEmptyDir(target_path.DirName().DirName(), &error);
+    }
+    if (error)
+      result = DELETE_FAILED;
   }
   return result;
 }
 
 // This method checks if Chrome is currently running or if the user has
 // cancelled the uninstall operation by clicking Cancel on the confirmation
 // box that Chrome pops up.
 InstallStatus IsChromeActiveOrUserCancelled(
     const InstallerState& installer_state,
     const Product& product) {
@@ skipping 633 matching lines @@
 
   // 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);
 
   return ret;
 }
 
 }  // namespace installer