Add best-effort/allow rollback flags on WorkItem.

chrome/installer/util/delete_tree_work_item.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 "chrome/installer/util/delete_tree_work_item.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/files/file_util.h"
@@ skipping 30 matching lines @@
     key_backup_paths_.reset(new base::ScopedTempDir[num_key_files_]);
     std::copy(key_paths.begin(), key_paths.end(), &key_paths_[0]);
   }
 }
 
 DeleteTreeWorkItem::~DeleteTreeWorkItem() {
 }
 
 // We first try to move key_path_ to backup_path. If it succeeds, we go ahead
 // and move the rest.
-bool DeleteTreeWorkItem::Do() {
+bool DeleteTreeWorkItem::DoImpl() {
   // Go through all the key files and see if we can open them exclusively
   // with only the FILE_SHARE_DELETE flag.  Once we know we have all of them,
   // we can delete them.
   std::vector<HANDLE> opened_key_files;
   opened_key_files.reserve(num_key_files_);
   bool abort = false;
   for (ptrdiff_t i = 0; !abort && i != num_key_files_; ++i) {
     base::FilePath& key_file = key_paths_[i];
     base::ScopedTempDir& backup = key_backup_paths_[i];
-    if (!ignore_failure_) {
+    if (rollback_enabled()) {
       if (!backup.CreateUniqueTempDirUnderPath(temp_path_)) {
         PLOG(ERROR) << "Could not create temp dir in " << temp_path_.value();
         abort = true;
       } else if (!base::CopyFile(key_file,
                      backup.path().Append(key_file.BaseName()))) {
         PLOG(ERROR) << "Could not back up " << key_file.value()
                     << " to directory " << backup.path().value();
         abort = true;
         if (!backup.Delete()) {
           PLOG(ERROR) << "Could not clean up temp dir in "
@@ skipping 28 matching lines @@
         abort = true;
       }
     }
   }
 
   std::for_each(opened_key_files.begin(), opened_key_files.end(), CloseHandle);
   opened_key_files.clear();
 
   if (abort) {
     LOG(ERROR) << "Could not exclusively hold all key files.";
-    return ignore_failure_;
+    return false;
   }
 
   // Now that we've taken care of the key files, take care of the rest.
   if (root_path_.empty() || !base::PathExists(root_path_))
     return true;
 
-  if (ignore_failure_) {
-    if (DeleteRoot())
-      return true;
-    // The file cannot be removed, but perhaps it can be moved into
-    // the temporary backup path. Consumers are responsible for making
-    // a best-effort attempt to remove the backup path. SelfCleaningTempDir
-    // is generally used for the backup path, so in the
-    // worst case the file(s) will be removed after the next reboot.
-    MoveRootToBackup();
+  // If rollback is not enabled, try to delete the root without making a backup.
+  // When that fails, fall back to moving the root to the temporary backup path.
+  // Consumers are responsible for making a best-effort attempt to remove the
+  // backup path. SelfCleaningTempDir is generally used for the backup path, so
+  // in the worst case the file(s) will be removed after the next reboot.
+  if (!rollback_enabled() && DeleteRoot())
     return true;
-  }
 
   // Attempt to move the root to the backup.
   return MoveRootToBackup();
 }
 
 // If there are files in backup paths move them back.
-void DeleteTreeWorkItem::Rollback() {
-  if (ignore_failure_)
-    return;
-
+void DeleteTreeWorkItem::RollbackImpl() {
   if (moved_to_backup_) {
     base::FilePath backup = GetBackupPath();
     DCHECK(!backup.empty());
     if (base::PathExists(backup))
       base::Move(backup, root_path_);
   }
 
   for (ptrdiff_t i = 0; i != num_key_files_; ++i) {
     base::ScopedTempDir& backup_dir = key_backup_paths_[i];
     if (!backup_dir.path().empty()) {
@@ skipping 33 matching lines @@
   if (backup.empty())
     return false;
   if (base::Move(root_path_, backup)) {
     moved_to_backup_ = true;
     return true;
   }
   PLOG(ERROR) << "Failed to move " << root_path_.value()
               << " to backup path " << backup.value();
   return false;
 }