Neglected nits from https://codereview.chromium.org/11412015/

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 197 matching lines @@
     bool* remove_setup,
     bool* remove_archive) {
   *remove_setup = true;
   *remove_archive = true;
 
   // If any multi-install product is left (other than App Host) we must leave
   // the installer and archive. For the App Host, we only leave the installer.
   if (!installer_state.is_multi_install()) {
     VLOG(1) << "Removing all installer files for a non-multi installation.";
   } else {
+    // Loop through all known products...
     for (size_t i = 0; i < BrowserDistribution::NUM_TYPES; ++i) {
       BrowserDistribution::Type dist_type =
           static_cast<BrowserDistribution::Type>(i);
       const installer::ProductState* product_state =
           original_state.GetProductState(
               installer_state.system_install(), dist_type);
+      // If the product is installed, in multi mode, and is not part of the
+      // active uninstallation...
       if (product_state && product_state->is_multi_install() &&
           !installer_state.FindProduct(dist_type)) {
         // setup.exe will not be removed as there is a remaining multi-install
         // product.
         *remove_setup = false;
         // As a special case, we can still remove the actual archive if the
         // only remaining product is the App Host.
         if (dist_type != BrowserDistribution::CHROME_APP_HOST) {
           VLOG(1) << "Keeping all installer files due to a remaining "
                   << "multi-install product.";
           *remove_archive = false;
           return;
         }
         VLOG(1) << "Keeping setup.exe due to a remaining "
                 << "app-host installation.";
       }
     }
     VLOG(1) << "Removing the installer archive.";
     if (remove_setup)
       VLOG(1) << "Removing setup.exe.";
   }
 }
 
 // Removes all files from the installer directory, leaving setup.exe iff
 // |remove_setup| is false.
 // Returns false in case of an error.
-bool RemoveInstallerFiles(const FilePath& install_directory,
+bool RemoveInstallerFiles(const FilePath& installer_directory,
                           bool remove_setup) {
   using file_util::FileEnumerator;
   FileEnumerator file_enumerator(
-      install_directory,
+      installer_directory,
       false,
       FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
   bool success = true;
 
   FilePath setup_exe_base_name(installer::kSetupExe);
 
   while (true) {
     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 install path " << to_delete.value();
+    VLOG(1) << "Deleting installer path " << to_delete.value();
     if (!file_util::Delete(to_delete, true)) {
       LOG(ERROR) << "Failed to delete path: " << to_delete.value();
       success = false;
     }
   }
 
   return success;
 }
 
 }  // namespace
@@ skipping 255 matching lines @@
   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();
   }
 
   return result;
 }
 
 DeleteResult DeleteChromeFilesAndFolders(const InstallerState& installer_state,
-                                         const FilePath& installer_path) {
+                                         const FilePath& setup_exe) {
   const FilePath& target_path = installer_state.target_path();
   if (target_path.empty()) {
     LOG(ERROR) << "DeleteChromeFilesAndFolders: no installation destination "
                << "path.";
     return DELETE_FAILED;  // Nothing else we can do to uninstall, so we return.
   }
 
   DeleteInstallTempDir(target_path);
 
   DeleteResult result = DELETE_SUCCEEDED;
 
   FilePath installer_directory;
-  if (target_path.IsParent(installer_path))
-    installer_directory = installer_path.DirName();
+  if (target_path.IsParent(setup_exe))
+    installer_directory = setup_exe.DirName();
 
   // Enumerate all the files in target_path recursively (breadth-first).
   // We delete a file or folder unless it is a parent/child of the installer
   // directory. For parents of the installer directory, we will later recurse
   // and delete all the children (that are not also parents/children of the
   // installer directory).
   using file_util::FileEnumerator;
   FileEnumerator file_enumerator(
       target_path, true, FileEnumerator::FILES | FileEnumerator::DIRECTORIES);
   while (true) {
@@ skipping 728 matching lines @@
   // (aka non-multi) installation or we are the Chrome Binaries.
 
   std::vector<FilePath> local_state_folders;
   GetLocalStateFolders(product, &local_state_folders);
   FilePath backup_state_file(BackupLocalStateFile(local_state_folders));
 
   if (product.is_chrome_app_host()) {
     DeleteAppHostFilesAndFolders(installer_state, product_state->version());
   } else if (!installer_state.is_multi_install() ||
              product.is_chrome_binaries()) {
+    FilePath setup_exe(cmd_line.GetProgram());
+    file_util::AbsolutePath(&setup_exe);
     DeleteResult delete_result = DeleteChromeFilesAndFolders(
-        installer_state, cmd_line.GetProgram());
+        installer_state, setup_exe);
     if (delete_result == DELETE_FAILED) {
       ret = installer::UNINSTALL_FAILED;
     } else if (delete_result == DELETE_REQUIRES_REBOOT) {
       ret = installer::UNINSTALL_REQUIRES_REBOOT;
     }
   }
 
   if (delete_profile)
     DeleteLocalState(local_state_folders, product.is_chrome_frame());
 
@@ skipping 90 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