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.

[fdoray, 2016/04/14 14:24:34]

I don't understand what this comment means.

[grt (UTC plus 2), 2016/04/14 15:47:02]

'No need to roll this back...'
The uncompressed archive of the current version of Chrome must be present
on-disk to support differential updates. When multiple old versions are present
(think of successive in-use updates: N is in-use, N+1, N+2, and N+3 have been
installed), the uncompressed archives from the older version(s) can be deleted
because they won't be used as the basis for future diff updates (only N3 will be
in the case above).

'...the "-full" channel...'
This is referring to a contract between the update server and the installer.
mini_installer.exe appends "-full" to Chrome's "additional parameters" reg value
before running setup.exe. the update server will unconditionally deliver a full
(rather than a diff) update if this suffix is present. So if this install fails
for other reasons, we don't need to roll-back the deletion of the uncompressed
archive since the next update is guaranteed to be a full rather than a diff
update.

+      delete_old_archive_work_item->set_allow_rollback(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 748 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