Add best-effort/allow rollback flags on WorkItem.

chrome/installer/setup/install_worker.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 contains the definitions of the installer functions that build
 // the WorkItemList used to install the application.
 
 #include "chrome/installer/setup/install_worker.h"
 
 #include <oaidl.h>
@@ skipping 254 matching lines @@
     const Product& product,
     WorkItemList* work_item_list) {
   DCHECK(installer_state.is_msi())
       << "This must only be called for MSI installations!";
 
   HKEY reg_root = installer_state.root_key();
   base::string16 uninstall_reg(product.distribution()->GetUninstallRegPath());
 
   WorkItem* delete_reg_key = work_item_list->AddDeleteRegKeyWorkItem(
       reg_root, uninstall_reg, KEY_WOW64_32KEY);
-  delete_reg_key->set_ignore_failure(true);
+  delete_reg_key->set_best_effort(true);
 }
 
 // Adds Chrome specific install work items to |install_list|.
 // |current_version| can be NULL to indicate no Chrome is currently installed.
 void AddChromeWorkItems(const InstallationState& original_state,
                         const InstallerState& installer_state,
                         const base::FilePath& setup_path,
                         const base::FilePath& archive_path,
                         const base::FilePath& src_path,
                         const base::FilePath& temp_path,
                         const Version* current_version,
                         const Version& new_version,
                         WorkItemList* install_list) {
   const base::FilePath& target_path = installer_state.target_path();
 
   if (current_version) {
-    // Delete the archive from an existing install to save some disk space.  We
-    // make this an unconditional work item since there's no need to roll this
-    // back; if installation fails we'll be moved to the "-full" channel anyway.
+    // Delete the archive from an existing install to save some disk space.
     base::FilePath old_installer_dir(
         installer_state.GetInstallerDirectory(*current_version));
     base::FilePath old_archive(
         old_installer_dir.Append(installer::kChromeArchive));
     // Don't delete the archive that we are actually installing from.
     if (archive_path != old_archive) {
-      install_list->AddDeleteTreeWorkItem(old_archive, temp_path)->
-          set_ignore_failure(true);
+      auto* delete_old_archive_work_item =
+          install_list->AddDeleteTreeWorkItem(old_archive, temp_path);
+      // Don't cause failure of |install_list| if this WorkItem fails.
+      delete_old_archive_work_item->set_best_effort(true);
+      // No need to roll this back; if installation fails we'll be moved to the
+      // "-full" channel anyway.
+      delete_old_archive_work_item->set_rollback_enabled(false);
     }
   }
 
   // Delete any new_chrome.exe if present (we will end up creating a new one
   // if required) and then copy chrome.exe
   base::FilePath new_chrome_exe(target_path.Append(installer::kChromeNewExe));
 
   install_list->AddDeleteTreeWorkItem(new_chrome_exe, temp_path);
 
   // TODO(grt): Remove this check in M35.
@@ skipping 54 matching lines @@
   bool check_for_duplicates = (current_version &&
                                *current_version == new_version);
   install_list->AddMoveTreeWorkItem(
       src_path.AppendASCII(new_version.GetString()).value(),
       target_path.AppendASCII(new_version.GetString()).value(),
       temp_path.value(),
       check_for_duplicates ? WorkItem::CHECK_DUPLICATES :
                              WorkItem::ALWAYS_MOVE);
 
   // Delete any old_chrome.exe if present (ignore failure if it's in use).
-  install_list->AddDeleteTreeWorkItem(
-      target_path.Append(installer::kChromeOldExe), temp_path)->
-          set_ignore_failure(true);
+  install_list
+      ->AddDeleteTreeWorkItem(target_path.Append(installer::kChromeOldExe),
+                              temp_path)
+      ->set_best_effort(true);
 }
 
 // Adds work items to remove COM registration for |product|'s deprecated
 // DelegateExecute verb handler.
 void AddCleanupDelegateExecuteWorkItems(const InstallerState& installer_state,
                                         const Product& product,
                                         WorkItemList* list) {
   if (product.is_chrome()) {
     VLOG(1) << "Adding unregistration items for DelegateExecute verb handler.";
     const base::string16 handler_class_uuid =
@@ skipping 747 matching lines @@
                          setup_path,
                          current_version,
                          new_version,
                          install_list);
 }
 
 void AddRegisterComDllWorkItems(const base::FilePath& dll_folder,
                                 const std::vector<base::FilePath>& dll_list,
                                 bool system_level,
                                 bool do_register,
-                                bool ignore_failures,
+                                bool best_effort,
                                 WorkItemList* work_item_list) {
   DCHECK(work_item_list);
   if (dll_list.empty()) {
     VLOG(1) << "No COM DLLs to register";
   } else {
     std::vector<base::FilePath>::const_iterator dll_iter(dll_list.begin());
     for (; dll_iter != dll_list.end(); ++dll_iter) {
       base::FilePath dll_path = dll_folder.Append(*dll_iter);
       WorkItem* work_item = work_item_list->AddSelfRegWorkItem(
           dll_path.value(), do_register, !system_level);
       DCHECK(work_item);
-      work_item->set_ignore_failure(ignore_failures);
+      work_item->set_best_effort(best_effort);
     }
   }
 }
 
 void AddSetMsiMarkerWorkItem(const InstallerState& installer_state,
                              BrowserDistribution* dist,
                              bool set,
                              WorkItemList* work_item_list) {
   DCHECK(work_item_list);
   DWORD msi_value = set ? 1 : 0;
   WorkItem* set_msi_work_item =
       work_item_list->AddSetRegValueWorkItem(installer_state.root_key(),
                                              dist->GetStateKey(),
                                              KEY_WOW64_32KEY,
                                              google_update::kRegMSIField,
                                              msi_value,
                                              true);
   DCHECK(set_msi_work_item);
-  set_msi_work_item->set_ignore_failure(true);
+  set_msi_work_item->set_best_effort(true);
   set_msi_work_item->set_log_message("Could not write MSI marker!");
 }
 
 void AddCleanupDeprecatedPerUserRegistrationsWorkItems(const Product& product,
                                                        WorkItemList* list) {
   if (product.is_chrome()) {
     BrowserDistribution* dist = product.distribution();
 
     // TODO(gab): Remove cleanup code for Metro after M53.
     VLOG(1) << "Adding unregistration items for per-user Metro keys.";
@@ skipping 164 matching lines @@
   // Unconditionally remove the legacy Quick Enable command from the binaries.
   // Do this even if multi-install Chrome isn't installed to ensure that it is
   // not left behind in any case.
   work_item_list->AddDeleteRegKeyWorkItem(
                       installer_state.root_key(), cmd_key, KEY_WOW64_32KEY)
       ->set_log_message("removing " + base::UTF16ToASCII(kCmdQuickEnableCf) +
                         " command");
 }
 
 }  // namespace installer