Temp dir cleanup:...

chrome/installer/setup/install_worker.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.
 //
 // This file contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <shlobj.h>
@@ skipping 61 matching lines @@
   // Then, if we got some, attempt to unregister the DLLs from the old
   // version directory and then re-register them in the new one.
   // Note that if we are migrating the install directory then we will not
   // successfully unregister the old DLLs.
   // TODO(robertshield): See whether we need to fix the migration case.
   // TODO(robertshield): If we ever remove a DLL from a product, this will
   // not unregister it on update. We should build the unregistration list from
   // saved state instead of assuming it is the same as the registration list.
   if (!com_dll_list.empty()) {
     if (old_version) {
-      FilePath old_dll_path(installer_state.target_path().Append(
-          UTF8ToWide(old_version->GetString())));
+      FilePath old_dll_path(installer_state.target_path().AppendASCII(
+          old_version->GetString()));
 
       installer::AddRegisterComDllWorkItems(old_dll_path,
                                             com_dll_list,
                                             installer_state.system_install(),
                                             false,  // Unregister
                                             true,   // May fail
                                             work_item_list);
     }
 
-    FilePath dll_path(installer_state.target_path().Append(
-        UTF8ToWide(new_version.GetString())));
+    FilePath dll_path(installer_state.target_path().AppendASCII(
+        new_version.GetString()));
     installer::AddRegisterComDllWorkItems(dll_path,
                                           com_dll_list,
                                           installer_state.system_install(),
                                           true,   // Register
                                           false,  // Must succeed.
                                           work_item_list);
   }
 }
 
 void AddInstallerCopyTasks(const InstallerState& installer_state,
@@ skipping 251 matching lines @@
 }
 
 // This is called when an MSI installation is run. It may be that a user is
 // attempting to install the MSI on top of a non-MSI managed installation.
 // If so, try and remove any existing uninstallation shortcuts, as we want the
 // uninstall to be managed entirely by the MSI machinery (accessible via the
 // Add/Remove programs dialog).
 void AddDeleteUninstallShortcutsForMSIWorkItems(
     const InstallerState& installer_state,
     const Product& product,
+    const FilePath& temp_path,
     WorkItemList* work_item_list) {
   DCHECK(installer_state.is_msi())
       << "This must only be called for MSI installations!";
 
   // First attempt to delete the old installation's ARP dialog entry.
   HKEY reg_root = installer_state.root_key();
   std::wstring uninstall_reg(product.distribution()->GetUninstallRegPath());
 
   WorkItem* delete_reg_key = work_item_list->AddDeleteRegKeyWorkItem(
       reg_root, uninstall_reg);
@@ skipping 10 matching lines @@
   if (uninstall_link.empty()) {
     LOG(ERROR) << "Failed to get location for shortcut.";
   } else {
     uninstall_link = uninstall_link.Append(
         product.distribution()->GetAppShortCutName());
     uninstall_link = uninstall_link.Append(
         product.distribution()->GetUninstallLinkName() + L".lnk");
     VLOG(1) << "Deleting old uninstall shortcut (if present): "
             << uninstall_link.value();
     WorkItem* delete_link = work_item_list->AddDeleteTreeWorkItem(
-        uninstall_link);
+        uninstall_link, temp_path);
     delete_link->set_ignore_failure(true);
     delete_link->set_log_message(
         "Failed to delete old uninstall shortcut.");
   }
 }
 
 // After a successful copying of all the files, this function is called to
 // do a few post install tasks:
 // - Handle the case of in-use-update by updating "opv" (old version) key or
 //   deleting it if not required.
 // - Register any new dlls and unregister old dlls.
 // - If this is an MSI install, ensures that the MSI marker is set, and sets
 //   it if not.
 // If these operations are successful, the function returns true, otherwise
 // false.
 bool AppendPostInstallTasks(const InstallerState& installer_state,
                             const FilePath& setup_path,
                             const FilePath& new_chrome_exe,
                             const Version* current_version,
                             const Version& new_version,
+                            const FilePath& temp_path,
                             WorkItemList* post_install_task_list) {
   DCHECK(post_install_task_list);
 
   HKEY root = installer_state.root_key();
   const Products& products = installer_state.products();
 
   // Append work items that will only be executed if this was an update.
   // We update the 'opv' key with the current version that is active and 'cmd'
   // key with the rename command to run.
   {
@@ skipping 85 matching lines @@
     for (size_t i = 0; i < products.size(); ++i) {
       const Product* product = products[i];
       AddSetMsiMarkerWorkItem(installer_state, product->distribution(), true,
                               post_install_task_list);
 
       // We want MSI installs to take over the Add/Remove Programs shortcut.
       // Make a best-effort attempt to delete any shortcuts left over from
       // previous non-MSI installations for the same type of install (system or
       // per user).
       AddDeleteUninstallShortcutsForMSIWorkItems(installer_state, *product,
+                                                 temp_path,
                                                  post_install_task_list);
     }
     if (installer_state.is_multi_install()) {
       AddSetMsiMarkerWorkItem(installer_state,
           installer_state.multi_package_binaries_distribution(), true,
           post_install_task_list);
     }
   }
 
   return true;
 }
 
 void AddInstallWorkItems(const InstallationState& original_state,
                          const InstallerState& installer_state,
                          const FilePath& setup_path,
                          const FilePath& archive_path,
                          const FilePath& src_path,
-                         const FilePath& temp_dir,
+                         const FilePath& temp_path,
                          const Version& new_version,
                          scoped_ptr<Version>* current_version,
                          WorkItemList* install_list) {
   DCHECK(install_list);
 
   const FilePath& target_path = installer_state.target_path();
 
   // A temp directory that work items need and the actual install directory.
-  install_list->AddCreateDirWorkItem(temp_dir);
+  install_list->AddCreateDirWorkItem(temp_path);
   install_list->AddCreateDirWorkItem(target_path);
 
   // Delete any new_chrome.exe if present (we will end up creating a new one
   // if required) and then copy chrome.exe
   FilePath new_chrome_exe(
       target_path.Append(installer::kChromeNewExe));
 
-  install_list->AddDeleteTreeWorkItem(new_chrome_exe);
+  install_list->AddDeleteTreeWorkItem(new_chrome_exe, temp_path);
   install_list->AddCopyTreeWorkItem(
       src_path.Append(installer::kChromeExe).value(),
       target_path.Append(installer::kChromeExe).value(),
-      temp_dir.value(), WorkItem::NEW_NAME_IF_IN_USE, new_chrome_exe.value());
+      temp_path.value(), WorkItem::NEW_NAME_IF_IN_USE, new_chrome_exe.value());
 
   // Extra executable for 64 bit systems.
   if (Is64bit()) {
     install_list->AddCopyTreeWorkItem(
         src_path.Append(installer::kWowHelperExe).value(),
         target_path.Append(installer::kWowHelperExe).value(),
-        temp_dir.value(), WorkItem::ALWAYS);
+        temp_path.value(), WorkItem::ALWAYS);
   }
 
   // If it is system level install copy the version folder (since we want to
   // take the permissions of %ProgramFiles% folder) otherwise just move it.
   if (installer_state.system_install()) {
     install_list->AddCopyTreeWorkItem(
-        src_path.Append(UTF8ToWide(new_version.GetString())).value(),
-        target_path.Append(UTF8ToWide(new_version.GetString())).value(),
-        temp_dir.value(), WorkItem::ALWAYS);
+        src_path.AppendASCII(new_version.GetString()).value(),
+        target_path.AppendASCII(new_version.GetString()).value(),
+        temp_path.value(), WorkItem::ALWAYS);
   } else {
     install_list->AddMoveTreeWorkItem(
-        src_path.Append(UTF8ToWide(new_version.GetString())).value(),
-        target_path.Append(UTF8ToWide(new_version.GetString())).value(),
-        temp_dir.value());
+        src_path.AppendASCII(new_version.GetString()).value(),
+        target_path.AppendASCII(new_version.GetString()).value(),
+        temp_path.value());
   }
 
   // Copy the default Dictionaries only if the folder doesn't exist already.
   install_list->AddCopyTreeWorkItem(
       src_path.Append(installer::kDictionaries).value(),
       target_path.Append(installer::kDictionaries).value(),
-      temp_dir.value(), WorkItem::IF_NOT_PRESENT);
+      temp_path.value(), WorkItem::IF_NOT_PRESENT);
 
   // Delete any old_chrome.exe if present.
   install_list->AddDeleteTreeWorkItem(
-      target_path.Append(installer::kChromeOldExe));
+      target_path.Append(installer::kChromeOldExe), temp_path);
 
   // Copy installer in install directory and
   // add shortcut in Control Panel->Add/Remove Programs.
-  AddInstallerCopyTasks(installer_state, setup_path, archive_path, temp_dir,
+  AddInstallerCopyTasks(installer_state, setup_path, archive_path, temp_path,
                         new_version, install_list);
 
   const HKEY 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];
 
     AddUninstallShortcutWorkItems(installer_state, setup_path, new_version,
                                   install_list, *product);
@@ skipping 14 matching lines @@
                               new_version, install_list);
 
   AddGoogleUpdateWorkItems(installer_state, install_list);
 
   // Append the tasks that run after the installation.
   AppendPostInstallTasks(installer_state,
                          setup_path,
                          new_chrome_exe,
                          current_version->get(),
                          new_version,
+                         temp_path,
                          install_list);
 }
 
 void AddRegisterComDllWorkItems(const FilePath& dll_folder,
                                 const std::vector<FilePath>& dll_list,
                                 bool system_level,
                                 bool do_register,
                                 bool ignore_failures,
                                 WorkItemList* work_item_list) {
   DCHECK(work_item_list);
@@ skipping 260 matching lines @@
       VLOG(1) << kIERefreshPolicy << " not supported.";
     }
 
     FreeLibrary(ieframe);
   } else {
     VLOG(1) << "Cannot load " << kIEFrameDll;
   }
 }
 
 }  // namespace installer