Temp dir cleanup:...

chrome/installer/setup/setup_main.cc

 // Copyright (c) 2011 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 <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
+#include "base/scoped_temp_dir.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 78 matching lines @@
   // it is a differential installer if chrome.7z is not found.
   if (!file_util::PathExists(uncompressed_archive)) {
     *archive_type = installer::INCREMENTAL_ARCHIVE_TYPE;
     VLOG(1) << "Differential patch found. Applying to existing archive.";
     if (!archive_version.get()) {
       LOG(ERROR) << "Can not use differential update when Chrome is not "
                  << "installed on the system.";
       return installer::CHROME_NOT_INSTALLED;
     }
 
-    FilePath existing_archive(installer_state.target_path().Append(
-        UTF8ToWide(archive_version->GetString())));
+    FilePath existing_archive(installer_state.target_path().AppendASCII(
+        archive_version->GetString()));
     existing_archive = existing_archive.Append(installer::kInstallerDir);
     existing_archive = existing_archive.Append(installer::kChromeArchive);
     if (int i = installer::ApplyDiffPatch(FilePath(existing_archive),
                                           FilePath(unpacked_file),
                                           FilePath(uncompressed_archive))) {
       LOG(ERROR) << "Binary patching failed with error " << i;
       return i;
     }
   } else {
     *archive_type = installer::FULL_ARCHIVE_TYPE;
   }
 
   // Unpack the uncompressed archive.
   return LzmaUtil::UnPackArchive(uncompressed_archive.value(),
       output_directory.value(), &unpacked_file);
 }
 
 // This function is called when --rename-chrome-exe option is specified on
 // setup.exe command line. This function assumes an in-use update has happened
 // for Chrome so there should be a file called new_chrome.exe on the file
 // system and a key called 'opv' in the registry. This function will move
 // new_chrome.exe to chrome.exe and delete 'opv' key in one atomic operation.
 installer::InstallStatus RenameChromeExecutables(
     const InstallerState& installer_state) {
   const FilePath &target_path = installer_state.target_path();
   FilePath chrome_exe(target_path.Append(installer::kChromeExe));
-  FilePath chrome_old_exe(target_path.Append(installer::kChromeOldExe));
   FilePath chrome_new_exe(target_path.Append(installer::kChromeNewExe));
 
-  scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
-  install_list->AddDeleteTreeWorkItem(chrome_old_exe);
-  FilePath temp_path;
-  if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) {
-    LOG(ERROR) << "Failed to create Temp directory " << temp_path.value();
+  // TODO(grt): Create the temp dir in the target_path rather than %TMP% and
+  // friends since it/they may be on another volume, which prevents us from
+  // moving an in-use chrome.exe out of the way.
+  ScopedTempDir temp_path;
+  if (!temp_path.CreateUniqueTempDir()) {
+    PLOG(ERROR) << "Failed to create Temp directory";
     return installer::RENAME_FAILED;
   }
-
+  scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
   install_list->AddCopyTreeWorkItem(chrome_new_exe.value(),
                                     chrome_exe.value(),
-                                    temp_path.value(),
+                                    temp_path.path().value(),
                                     WorkItem::IF_DIFFERENT,
                                     std::wstring());
-  install_list->AddDeleteTreeWorkItem(chrome_new_exe);
+  install_list->AddDeleteTreeWorkItem(chrome_new_exe, temp_path.path());
 
   HKEY reg_root = installer_state.root_key();
   const Products& products = installer_state.products();
   for (size_t i = 0; i < products.size(); ++i) {
     const Product* product = products[i];
     BrowserDistribution* browser_dist = product->distribution();
     std::wstring version_key(browser_dist->GetVersionKey());
     install_list->AddDeleteRegValueWorkItem(reg_root,
                                             version_key,
                                             google_update::kRegOldVersionField);
     install_list->AddDeleteRegValueWorkItem(reg_root,
                                             version_key,
                                             google_update::kRegRenameCmdField);
   }
   installer::InstallStatus ret = installer::RENAME_SUCCESSFUL;
   if (!install_list->Do()) {
     LOG(ERROR) << "Renaming of executables failed. Rolling back any changes.";
     install_list->Rollback();
     ret = installer::RENAME_FAILED;
   }
-  file_util::Delete(temp_path, true);
   return ret;
 }
 
 // The supported multi-install modes are:
 // --multi-install --chrome --chrome-frame --ready-mode
 //   - If a non-multi Chrome Frame installation is present, Chrome Frame is
 //     removed from |installer_state|'s list of products (thereby preserving
 //     the existing SxS install).
 //   - If a multi Chrome Frame installation is present, its options are
 //     preserved (i.e., the --ready-mode command-line option is ignored).
@@ skipping 279 matching lines @@
   // If --install-archive is given, get the user specified value
   if (cmd_line.HasSwitch(installer::switches::kInstallArchive)) {
     archive = cmd_line.GetSwitchValuePath(
         installer::switches::kInstallArchive);
   }
   VLOG(1) << "Archive found to install Chrome " << archive.value();
   const Products& products = installer_state.products();
 
   // Create a temp folder where we will unpack Chrome archive. If it fails,
   // then we are doomed, so return immediately and no cleanup is required.
-  FilePath temp_path;
-  if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) {
-    LOG(ERROR) << "Could not create temporary path.";
+  ScopedTempDir temp_path;
+  if (!temp_path.CreateUniqueTempDir()) {
+    PLOG(ERROR) << "Could not create temporary path.";
     InstallUtil::WriteInstallerResult(system_install,
         installer_state.state_key(), installer::TEMP_DIR_FAILED,
         IDS_INSTALL_TEMP_DIR_FAILED_BASE, NULL);
     return installer::TEMP_DIR_FAILED;
   }
-  VLOG(1) << "created path " << temp_path.value();
+  VLOG(1) << "created path " << temp_path.path().value();
 
-  FilePath unpack_path(temp_path.Append(installer::kInstallSourceDir));
-  if (UnPackArchive(archive, installer_state, temp_path, unpack_path,
+  FilePath unpack_path(temp_path.path().Append(installer::kInstallSourceDir));
+  if (UnPackArchive(archive, installer_state, temp_path.path(), unpack_path,
                     archive_type)) {
     install_status = installer::UNCOMPRESSION_FAILED;
     InstallUtil::WriteInstallerResult(system_install,
         installer_state.state_key(), install_status,
         IDS_INSTALL_UNCOMPRESSION_FAILED_BASE, NULL);
   } else {
     VLOG(1) << "unpacked to " << unpack_path.value();
     FilePath src_path(unpack_path.Append(installer::kInstallSourceChromeDir));
     scoped_ptr<Version>
         installer_version(installer::GetMaxVersionFromArchiveDir(src_path));
@@ skipping 32 matching lines @@
             InstallUtil::WriteInstallerResult(system_install,
                 installer_state.state_key(), install_status,
                 IDS_INSTALL_HIGHER_VERSION_CF_BASE, NULL);
           }
         }
       }
 
       if (!higher_version_installed) {
         // We want to keep uncompressed archive (chrome.7z) that we get after
         // uncompressing and binary patching. Get the location for this file.
-        FilePath archive_to_copy(temp_path.Append(installer::kChromeArchive));
+        FilePath archive_to_copy(
+            temp_path.path().Append(installer::kChromeArchive));
         FilePath prefs_source_path(cmd_line.GetSwitchValueNative(
             installer::switches::kInstallerData));
         install_status = installer::InstallOrUpdateProduct(original_state,
-            installer_state, cmd_line.GetProgram(), archive_to_copy, temp_path,
-            prefs_source_path, prefs, *installer_version);
+            installer_state, cmd_line.GetProgram(), archive_to_copy,
+            temp_path.path(), prefs_source_path, prefs, *installer_version);
 
         int install_msg_base = IDS_INSTALL_FAILED_BASE;
         std::wstring chrome_exe;
         if (install_status == installer::SAME_VERSION_REPAIR_FAILED) {
           if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) {
             install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_CF_BASE;
           } else {
             install_msg_base = IDS_SAME_VERSION_REPAIR_FAILED_BASE;
           }
         } else if (install_status != installer::INSTALL_FAILED) {
@@ skipping 64 matching lines @@
       const Product* product = products[i];
       product->distribution()->LaunchUserExperiment(install_status,
           *installer_version, *product, system_install);
     }
   }
 
   // Delete temporary files. These include install temporary directory
   // and master profile file if present. Note that we do not care about rollback
   // here and we schedule for deletion on reboot below if the deletes fail. As
   // such, we do not use DeleteTreeWorkItem.
-  VLOG(1) << "Deleting temporary directory " << temp_path.value();
-  bool cleanup_success = file_util::Delete(temp_path, true);
+  VLOG(1) << "Deleting temporary directory " << temp_path.path().value();
+  bool cleanup_success = temp_path.Delete();
   if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
     std::wstring prefs_path = cmd_line.GetSwitchValueNative(
         installer::switches::kInstallerData);
     cleanup_success = file_util::Delete(prefs_path, true) && cleanup_success;
   }
 
   // The above cleanup has been observed to fail on several users machines.
   // Specifically, it appears that the temp folder may be locked when we try
   // to delete it. This is Rather Bad in the case where we have failed updates
   // as we end up filling users' disks with large-ish temp files. To mitigate
   // this, if we fail to delete the temp folders, then schedule them for
   // deletion at next reboot.
   if (!cleanup_success) {
-    ScheduleDirectoryForDeletion(temp_path.value().c_str());
+    ScheduleDirectoryForDeletion(temp_path.path().value().c_str());
     if (cmd_line.HasSwitch(installer::switches::kInstallerData)) {
       std::wstring prefs_path = cmd_line.GetSwitchValueNative(
           installer::switches::kInstallerData);
       ScheduleDirectoryForDeletion(prefs_path.c_str());
     }
   }
 
   return install_status;
 }
 
@@ skipping 89 matching lines @@
                                     int* exit_code) {
   bool handled = true;
   // TODO(tommi): Split these checks up into functions and use a data driven
   // map of switch->function.
   if (cmd_line.HasSwitch(installer::switches::kUpdateSetupExe)) {
     installer::InstallStatus status = installer::SETUP_PATCH_FAILED;
     // If --update-setup-exe command line option is given, we apply the given
     // patch to current exe, and store the resulting binary in the path
     // specified by --new-setup-exe. But we need to first unpack the file
     // given in --update-setup-exe.
-    FilePath temp_path;
-    if (!file_util::CreateNewTempDirectory(L"chrome_", &temp_path)) {
-      LOG(ERROR) << "Could not create temporary path.";
+    ScopedTempDir temp_path;
+    if (!temp_path.CreateUniqueTempDir()) {
+      PLOG(ERROR) << "Could not create temporary path.";
     } else {
       std::wstring setup_patch = cmd_line.GetSwitchValueNative(
           installer::switches::kUpdateSetupExe);
       VLOG(1) << "Opening archive " << setup_patch;
       std::wstring uncompressed_patch;
-      if (LzmaUtil::UnPackArchive(setup_patch, temp_path.value(),
+      if (LzmaUtil::UnPackArchive(setup_patch, temp_path.path().value(),
                                   &uncompressed_patch) == NO_ERROR) {
         FilePath old_setup_exe = cmd_line.GetProgram();
         FilePath new_setup_exe = cmd_line.GetSwitchValuePath(
             installer::switches::kNewSetupExe);
         if (!installer::ApplyDiffPatch(old_setup_exe,
                                        FilePath(uncompressed_patch),
                                        new_setup_exe))
           status = installer::NEW_VERSION_UPDATED;
       }
     }
 
     *exit_code = InstallUtil::GetInstallReturnCode(status);
     if (*exit_code) {
       LOG(WARNING) << "setup.exe patching failed.";
       InstallUtil::WriteInstallerResult(installer_state->system_install(),
           installer_state->state_key(), status, IDS_SETUP_PATCH_FAILED_BASE,
           NULL);
     }
-    file_util::Delete(temp_path, true);
   } else if (cmd_line.HasSwitch(installer::switches::kShowEula)) {
     // Check if we need to show the EULA. If it is passed as a command line
     // then the dialog is shown and regardless of the outcome setup exits here.
     std::wstring inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
     if (installer::EULA_REJECTED != *exit_code)
       GoogleUpdateSettings::SetEULAConsent(*installer_state, true);
   } else if (cmd_line.HasSwitch(
       installer::switches::kRegisterChromeBrowser)) {
@@ skipping 359 matching lines @@
   if (!(installer_state.is_msi() && is_uninstall))
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }